基于遗传算法的试题组卷（二）
实例讲解
一、准备工作
1、问题实体
问题实体包含编号、类型（类型即题型，分为五种：单选，多选，判断，填空，问答， 分别用1、2、3、4、5表示）、分数、难度系数、知识点。一道题至少有一个知识点，为简单易懂，知识点用List 表示（知识点编号集合）。
代码如下：
public class Problem
{
public Problem()
{
ID = 0;
Type = 0;
Score = 0;
Difficulty = 0.00;
Points = new List<int>();
}
public Problem(Problem p)
{
this.ID = p.ID;
this.Type = p.Type;
this.Score = p.Score;
this.Difficulty = p.Difficulty;
this.Points = p.Points;
}
/// 2、题库
为了简单，这里没有用数据库，题目信息临时创建，保存在内存中。因为对不同层次的考生一道题目在不同试卷中的分数可能不一样，因此题目分数一般是老师出卷时定的，不保存在题库中。且单选，多选，判断题每题分数应该相同，填空题一般根据空数来定分数，而问答题一般根据题目难度来定的，因此这里的单选、多选、判断分数相同，填空空数取1-4间的随机数，填空题分数即为空数，问答题即为该题难度系数*10取整。这里各种题型均为1000题，具体应用时改为数据库即可。
代码如下：
public class DB
{
/// 3、 试卷实体
试卷一般包含试卷编号，试卷名称，考试时间，难度系数，知识点分布，总题数， 总分数，各种题型所占比率等属性，这里为简单去掉了试卷名称跟考试时间。其中的知识点分布即老师出卷时选定本试卷要考查的知识点，这里用List（知识点编号集合）表示。
代码如下：
public class Paper
{
/// 二、开始遗传算法组卷之旅
准备工作已经OK，下面就按上一篇介绍的流程进行操作啦！
1、产生初始种群
这里保证题数跟总分达到出卷要求即可，但为操作方便，这里再定义一个种群个体实体类Unit，包含编号、适应度、题数、总分、难度系数、知识点分布、包含的题目等信息（也可以修改一下试卷实体，用试卷实体表示）：
public class Unit
{
public Unit()
{
ID = 0;
AdaptationDegree = 0.00;
KPCoverage = 0.00;
ProblemList = new List<Problem>();
}
/// 下面即来产生初始种群，按个体数量，期望试卷知识点分布，各类型题目数等限制产生初始种群：
/// 初始种群
public List<Unit> CSZQ(int count, Paper paper, List<Problem> problemList)
{
List<Unit> unitList = new List<Unit>();
int[] eachTypeCount = paper.EachTypeCount;
Unit unit;
Random rand = new Random();
for (int i = 0; i < count; i++)
{
unit = new Unit();
unit.ID = i + 1;
unit.AdaptationDegree = 0.00;
//总分限制
while (paper.TotalScore != unit.SumScore)
{
unit.ProblemList.Clear();
//各题型题目数量限制
for (int j = 0; j < eachTypeCount.Length; j++)
{
List<Problem> oneTypeProblem = problemList
.Where(o => o.Type == (j + 1))
.Where(p => IsContain(paper, p))
.ToList();
Problem temp = new Problem();
for (int k = 0; k < eachTypeCount[j]; k++)
{
//选择不重复的题目
int index = rand.Next(0, oneTypeProblem.Count - k);
unit.ProblemList.Add(oneTypeProblem[index]);
temp = oneTypeProblem[oneTypeProblem.Count - 1 - k];
oneTypeProblem[oneTypeProblem.Count - 1 - k] = oneTypeProblem[index];
oneTypeProblem[index] = temp;
}
}
}
unitList.Add(unit);
}
//计算知识点覆盖率及适应度
unitList = GetKPCoverage(unitList, paper);
unitList = GetAdaptationDegree(unitList, paper, kpcoverage, difficulty);
return unitList;
}
2、计算种群个体的适应度
在上面的代码中最后调用了两个方法，GetKPCoverage跟GetAdaptationDegree，这两个方法分别是计算种群中个体的知识点覆盖率跟适应度。
关于种群个体的知识点覆盖率在上一篇文章中已经说过了（知识点分布用一个个体知识点的覆盖率来衡量，例如期望本试卷包含N个知识点，而一个个体中所有题目知识点的并集中包含M个（M<=N），则知识点的覆盖率为M/N。），具体算法如下：
/// List
public List<Unit> GetKPCoverage(List<Unit> unitList, Paper paper)
{
List<int> kp;
for (int i = 0; i < unitList.Count; i++)
{
kp = new List<int>();
unitList[i].ProblemList.ForEach(delegate(Problem p)
{
kp.AddRange(p.Points);
});
//个体所有题目知识点并集跟期望试卷知识点交集
var common = kp.Intersect(paper.Points);
unitList[i].KPCoverage = common.Count() * 1.00 / paper.Points.Count;
}
return unitList;
}
适应度方法的确定上一篇文章里已经说过，即：
f=1-(1-M/N)*f1-|EP-P|*f2
其中M/N为知识点覆盖率，EP为期望难度系数，P为种群个体难度系数，f1为知识点分布的权重，f2为难度系数所占权重。当f1=0时退化为只限制试题难度系数，当f2=0时退化为只限制知识点分布。 实现代码如下：
/// List
public List<Unit> GetAdaptationDegree(List<Unit> unitList, Paper paper, double KPCoverage, double Difficulty)
{
unitList = GetKPCoverage(unitList, paper);
for (int i = 0; i < unitList.Count; i++)
{
unitList[i].AdaptationDegree = 1 - (1 - unitList[i].KPCoverage) * KPCoverage - Math.Abs(unitList[i].Difficulty - paper.Difficulty) * Difficulty;
}
return unitList;
}
3、选择算子
这里选择算子采用轮盘赌选择法，即适应度越大的被选择到的概率越大。比如说种群中有20个个体，那么每个个体的适应度除以20个个体适应度的和得到的就是该个体的被选择的概率。轮盘赌选择时，每个个体类似于轮盘中的一小块扇形，扇形的大小与该个体被选择的概率成正比。那么，扇形越大的个体被选择的概率越大。这就是轮盘赌选择法。 算法实现代码如下：
/// 进入下一代的种群
public List<Unit> Select(List<Unit> unitList, int count)
{
List<Unit> selectedUnitList = new List<Unit>();
//种群个体适应度和
double AllAdaptationDegree = 0;
unitList.ForEach(delegate(Unit u)
{
AllAdaptationDegree += u.AdaptationDegree;
});
Random rand = new Random();
while (selectedUnitList.Count != count)
{
//选择一个0—1的随机数字
double degree = 0.00;
double randDegree = rand.Next(1, 100) * 0.01 * AllAdaptationDegree;
//选择符合要求的个体
for (int j = 0; j < unitList.Count; j++)
{
degree += unitList[j].AdaptationDegree;
if (degree >= randDegree)
{
//不重复选择
if (!selectedUnitList.Contains(unitList[j]))
{
selectedUnitList.Add(unitList[j]);
}
break;
}
}
}
return selectedUnitList;
}
4、交叉算子
交叉算子在上一篇也做了说明，写程序时为方便略做了一点更改，即把多点交叉改为单点交叉。在交叉过程在有几个地方需要注意，一是要保正总分不变，二是保证交叉后没有重复个体，算法实现如下：
/// List
public List<Unit> Cross(List<Unit> unitList, int count, Paper paper)
{
List<Unit> crossedUnitList = new List<Unit>();
Random rand = new Random();
while (crossedUnitList.Count != count)
{
//随机选择两个个体
int indexOne = rand.Next(0, unitList.Count);
int indexTwo = rand.Next(0, unitList.Count);
Unit unitOne;
Unit unitTwo;
if (indexOne != indexTwo)
{
unitOne = unitList[indexOne];
unitTwo = unitList[indexTwo];
//随机选择一个交叉位置
int crossPosition = rand.Next(0, unitOne.ProblemCount - 2);
//保证交叉的题目分数合相同
double scoreOne = unitOne.ProblemList[crossPosition].Score + unitOne.ProblemList[crossPosition + 1].Score;
double scoreTwo = unitTwo.ProblemList[crossPosition].Score + unitTwo.ProblemList[crossPosition + 1].Score;
if (scoreOne == scoreTwo)
{
//两个新个体
Unit unitNewOne = new Unit();
unitNewOne.ProblemList.AddRange(unitOne.ProblemList);
Unit unitNewTwo = new Unit();
unitNewTwo.ProblemList.AddRange(unitTwo.ProblemList);
//交换交叉位置后面两道题
for (int i = crossPosition; i < crossPosition + 2; i++)
{
unitNewOne.ProblemList[i] = new Problem(unitTwo.ProblemList[i]);
unitNewTwo.ProblemList[i] = new Problem(unitOne.ProblemList[i]);
}
//添加到新种群集合中
unitNewOne.ID = crossedUnitList.Count;
unitNewTwo.ID = unitNewOne.ID + 1;
if (crossedUnitList.Count < count)
{
crossedUnitList.Add(unitNewOne);
}
if (crossedUnitList.Count < count)
{
crossedUnitList.Add(unitNewTwo);
}
}
}
//过滤重复个体
crossedUnitList = crossedUnitList.Distinct(new ProblemComparer()).ToList();
}
//计算知识点覆盖率及适应度
crossedUnitList = GetKPCoverage(crossedUnitList, paper);
crossedUnitList = GetAdaptationDegree(crossedUnitList, paper, kpcoverage, difficulty);
return crossedUnitList;
}
上面过滤重复个体中用到了ProblemComparer类，这是一个自定义的比较类，代码如下：
public class ProblemComparer : IEqualityComparer<Unit>
{
public bool Equals(Unit x, Unit y)
{
bool result = true;
for (int i = 0; i < x.ProblemList.Count; i++)
{
if (x.ProblemList[i].ID != y.ProblemList[i].ID)
{
result = false;
break;
}
}
return result;
}
public int GetHashCode(Unit obj)
{
return obj.ToString().GetHashCode();
}
}
5、 变异算子
在变异过程中主要是要保证替换题目至少包含一个被替换题的有效知识点（期望试卷中也包含此知识点），并要类型相同，分数相同而题号不同。 算法实现代码如下：
/// List
public List<Unit> Change(List<Unit> unitList, List<Problem> problemList, Paper paper)
{
Random rand = new Random();
int index = 0;
unitList.ForEach(delegate(Unit u)
{
//随机选择一道题
index = rand.Next(0, u.ProblemList.Count);
Problem temp = u.ProblemList[index];
//得到这道题的知识点
Problem problem = new Problem();
for (int i = 0; i < temp.Points.Count; i++)
{
if (paper.Points.Contains(temp.Points[i]))
{
problem.Points.Add(temp.Points[i]);
}
}
//从数据库中选择包含此题有效知识点的同类型同分数不同题号试题
var otherDB = from a in problemList
where a.Points.Intersect(problem.Points).Count() > 0
select a;
List<Problem> smallDB = otherDB.Where(p => IsContain(paper, p)).Where(o => o.Score == temp.Score && o.Type == temp.Type && o.ID != temp.ID).ToList();
//从符合要求的试题中随机选一题替换
if (smallDB.Count > 0)
{
int changeIndex = rand.Next(0, smallDB.Count);
u.ProblemList[index] = smallDB[changeIndex];
}
});
//计算知识点覆盖率跟适应度
unitList = GetKPCoverage(unitList, paper);
unitList = GetAdaptationDegree(unitList, paper, kpcoverage, difficulty);
return unitList;
}
遗传算法主要算法上面都已实现，现在就是调用了。调用过程按如下流程图进行：
这里初始种群大小设定为20，最大迭代次数为500，适应度为0.98，选择算子选择次数为10次，交叉算子产生的个体数量为20，期望试卷难度系数为0.72，总分为100分，各种题型题数为：20（单选）, 5（多选）, 10（判断）, 7（填空）, 5（问答），包含的知识点为：1, 3, 5, 7, 9, 11, 13, 15, 17, 19, 21, 23, 25, 27, 29, 31, 33, 35, 37, 39, 41, 43, 45, 47, 49, 51, 53, 55, 57, 59, 61, 63, 65, 67, 69, 71, 73, 75, 77, 79, 81。代码如下：
/// 最后在控制台中调用此方法即可。
7、其他辅助方法
在上面的代码中还调用了几个辅助方法，下面一并给出：
#region 是否达到目标
/// bool
public bool IsEnd(List<Unit> unitList, double endcondition)
{
if (unitList.Count > 0)
{
for (int i = 0; i < unitList.Count; i++)
{
if (unitList[i].AdaptationDegree >= endcondition)
{
return true;
}
}
}
return false;
}
#endregion
#region 显示结果
/// #region 题目知识点是否符合试卷要求
/// bool
private bool IsContain(Paper paper, Problem problem)
{
for (int i = 0; i < problem.Points.Count; i++)
{
if (paper.Points.Contains(problem.Points[i]))
{
return true;
}
}
return false;
}
#endregion