DNA序列的聚类与判别

已知给定的前20个DNA序列,1-10为A类,11-20为B类,从中提取特征,构造分类方法,并用这些已知类别的序列,衡量方法是否足够好。然后用该方法对另外20 个未标明类别的人工序列(标号21—40)进行分类。

参考了网上一篇文章的做法,利用模糊聚类分析的方法,先将64个密码子的分布率作为前20个序列的特征分别提取出来,再利用夹角余弦法建立模糊相似矩阵,进而得到模糊等价矩阵,接着利用不同的阈值确定截矩阵,通过分析后得到确定的分类。

重复代码比较多,望见谅~

package cn.gao;

import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.OutputStream;
import java.text.DecimalFormat;
import java.util.ArrayList;
import java.util.List;

import org.junit.Before;
import org.junit.BeforeClass;
import org.junit.Test;

public class DNATest {
	
	static List<double[]> list = new ArrayList<double[]>();  //将40个序列的密码子信息保存到该list中
	double[][] matrix1 = new double[20][20];  //用来保存模糊相似矩阵
	double[][] matrix2 = new double[20][20];  //用来保存模糊等价矩阵
	double[][] matrix0 = new double[20][20];  //模糊相似矩阵的副本
	int[][] matrix3 = new int[20][20];  //用来保存截矩阵

	@BeforeClass
	public static void run(){
		
		/*String s1 = "aggcacggaaaaacgggaataacggaggaggacttggcacggcattacacggaggacgaggtaaaggaggcttgtctacggccggaagtgaagggggatatgaccgcttgg";
		String s2 = "cggaggacaaacgggatggcggtattggaggtggcggactgttcggggaattattcggtttaaacgggacaaggaaggcggctggaacaaccggacggtggcagcaaagga";
		String s3 = "gggacggatacggattctggccacggacggaaaggaggacacggcggacatacacggcggcaacggacggaacggaggaaggagggcggcaatcggtacggaggcggcgga";
		String s4 = "atggataacggaaacaaaccagacaaacttcggtagaaatacagaagcttagatgcatatgttttttaaataaaatttgtattattatggtatcataaaaaaaggttgcga";
		String s5 = "cggctggcggacaacggactggcggattccaaaaacggaggaggcggacggaggctacaccaccgtttcggcggaaaggcggagggctggcaggaggctcattacggggag";
		String s6 = "atggaaaattttcggaaaggcggcaggcaggaggcaaaggcggaaaggaaggaaacggcggatatttcggaagtggatattaggagggcggaataaaggaacggcggcaca";
		String s7 = "atgggattattgaatggcggaggaagatccggaataaaatatggcggaaagaacttgttttcggaaatggaaaaaggactaggaatcggcggcaggaaggatatggaggcg";
		String s8 = "atggccgatcggcttaggctggaaggaacaaataggcggaattaaggaaggcgttctcgcttttcgacaaggaggcggaccataggaggcggattaggaacggttatgagg";
		String s9 = "atggcggaaaaaggaaatgtttggcatcggcgggctccggcaactggaggttcggccatggaggcgaaaatcgtgggcggcggcagcgctggccggagtttgaggagcgcg";
		String s10 = "tggccgcggaggggcccgtcgggcgcggatttctacaagggcttcctgttaaggaggtggcatccaggcgtcgcacgctcggcgcggcaggaggcacgcgggaaaaaacg";
		String s11 = "gttagatttaacgttttttatggaatttatggaattataaatttaaaaatttatattttttaggtaagtaatccaacgtttttattactttttaaaattaaatatttatt";
		String s12 = "gtttaattactttatcatttaatttaggttttaattttaaatttaatttaggtaagatgaatttggttttttttaaggtagttatttaattatcgttaaggaaagttaaa";
		String s13 = "gtattacaggcagaccttatttaggttattattattatttggattttttttttttttttttttaagttaaccgaattattttctttaaagacgttacttaatgtcaatgc";
		String s14 = "gttagtcttttttagattaaattattagattatgcagtttttttacataagaaaatttttttttcggagttcatattctaatctgtctttattaaatcttagagatatta";
		String s15 = "gtattatatttttttatttttattattttagaatataatttgaggtatgtgtttaaaaaaaatttttttttttttttttttttttttttttttaaaatttataaatttaa";
		String s16 = "gttatttttaaatttaattttaattttaaaatacaaaatttttactttctaaaattggtctctggatcgataatgtaaacttattgaatctatagaattacattattgat";
		String s17 = "gtatgtctatttcacggaagaatgcaccactatatgatttgaaattatctatggctaaaaaccctcagtaaaatcaatccctaaacccttaaaaaacggcggcctatccc";
		String s18 = "gttaattatttattccttacgggcaattaattatttattacggttttatttacaattttttttttttgtcctatagagaaattacttacaaaacgttattttacatactt";
		String s19 = "gttacattatttattattatccgttatcgataattttttacctcttttttcgctgagtttttattcttactttttttcttctttatataggatctcatttaatatcttaa";
		String s20 = "gtatttaactctctttactttttttttcactctctacattttcatcttctaaaactgtttgatttaaacttttgtttctttaaggattttttttacttatcctctgttat";*/
	    //这里是给定的前20个序列
		     
		
		String s1 = "tttagctcagtccagctagctagtttacaatttcgacaccagtttcgcaccatcttaaatttcgatccgtaccgtaatttagcttagatttggatttaaaggatttagattga";
		String s2 = "tttagtacagtagctcagtccaagaacgatgtttaccgtaacgtqacgtaccgtacgctaccgttaccggattccggaaagccgattaaggaccgatcgaaaggg";
		String s3 = "cgggcggatttaggccgacggggacccgggattcgggacccgaggaaattcccggattaaggtttagcttcccgggatttagggcccggatggctgggaccc";
		String s4 = "tttagctagctactttagctatttttagtagctagccagcctttaaggctagctttagctagcattgttctttattgggacccaagttcgacttttacgatttagttttgaccgt";
		String s5 = "gaccaaaggtgggctttagggacccgatgctttagtcgcagctggaccagttccccagggtattaggcaaaagctgacgggcaattgcaatttaggcttaggcca";
		String s6 = "gatttactttagcatttttagctgacgttagcaagcattagctttagccaatttcgcatttgccagtttcgcagctcagttttaacgcgggatctttagcttcaagctttttac";
		String s7 = "ggattcggatttacccggggattggcggaacgggacctttaggtcgggacccattaggagtaaatgccaaaggacgctggtttagccagtccgttaaggcttag";
		String s8 = "tccttagatttcagttactatatttgacttacagtctttgagatttcccttacgattttgacttaaaatttagacgttagggcttatcagttatggattaatttagcttattttcga";
		String s9 = "ggccaattccggtaggaaggtgatggcccgggggttcccgggaggatttaggctgacgggccggccatttcggtttagggagggccgggacgcgttagggc";
		String s10 = "cgctaagcagctcaagctcagtcagtcacgtttgccaagtcagtaatttgccaaagttaaccgttagctgacgctgaacgctaaacagtattagctgatgactcgta";
		String s11 = "ttaaggacttaggctttagcagttactttagtttagttccaagctacgtttacgggaccagatgctagctagcaatttattatccgtattaggcttaccgtaggtttagcgt";
		String s12 = "gctaccgggcagtctttaacgtagctaccgtttagtttgggcccagccttgcggtgtttcggattaaattcgttgtcagtcgctctrtgggtttagtcattcccaaaagg";
		String s13 = "cagttagctgaatcgtttagccatttgacgtaaacatgattttacgtacgtaaattttagccctgacgtttagctaggaatttatgctgacgtagcgatcgactttagcac";
		String s14 = "cggttagggcaaaggttggatttcgacccagggggaaagcccgggacccgaacccagggctttagcgtaggctgacgctaggcttaggttggaacccggaaa";
		String s15 = "gcggaagggcgtaggtttgggatgcttagccgtaggctagctttcgacacgatcgattcgcaccacaggataaaagttaagggaccggtaagtcgcggtagcc";
		String s16 = "ctagctacgaacgctttaggcgcccccgggagtagtcgttaccgttagtatagcagtcgcagtcgcaattcgcaaaagtccccagctttagccccagagtcgacg";
		String s17 = "gggatgctgacgctggttagctttaggcttagcgtagctttagggccccagtctgcaggaaatgcccaaaggaggcccaccgggtagatgccasagtgcaccgt";
		String s18 = "aacttttagggcatttccagttttacgggttattttcccagttaaactttgcaccattttacgtgttacgatttacgtataatttgaccttattttggacactttagtttgggttac";
		String s19 = "ttagggccaagtcccgaggcaaggaattctgatccaagtccaatcacgtacagtccaagtcaccgtttgcagctaccgtttaccgtacgttgcaagtcaaatccat";
		String s20 = "ccattagggtttatttacctgtttattttttcccgagaccttaggtttaccgtactttttaacggtttacctttgaaatttttggactagcttaccctggatttaacggccagttt";
		//这里是后20个待判别的序列
		classify(s1);
		classify(s2);
		classify(s3);
		classify(s4);
		classify(s5);
		classify(s6);
		classify(s7);
		classify(s8);
		classify(s9);
		classify(s10);
		classify(s11);
		classify(s12);
		classify(s13);
		classify(s14);
		classify(s15);
		classify(s16);
		classify(s17);
		classify(s18);
		classify(s19);
		classify(s20);
	}
	
	//得到模糊相似矩阵,保存到matrix1二维数组中,并打印到txt文件
	@Before
	public void matrix1() throws IOException{
		
		//将模糊相似矩阵输出到txt文件
		FileOutputStream out = new FileOutputStream("C:\\Users\\Administrator\\Desktop\\模糊相似矩阵.txt");
		
		//规定输出的格式为保留小数点后3位
		DecimalFormat df = new DecimalFormat("0.000");
		for(int i = 0;i<20;i++){
			for(int j = 0;j<20;j++){
				matrix1[i][j] = fenzi(i,j)/fenmu(i,j);
				matrix0[i][j] = matrix1[i][j];  //模糊相似矩阵的副本
			}
		}
		
		out.write("模糊相似矩阵:\r\n".getBytes());
		for(int a = 0;a<20;a++){
			for(int b = 0;b<a+1;b++){
				//System.out.print(df.format(matrix1[a][b])+"  ");
				out.write((df.format(matrix1[a][b])+"  ").getBytes());
			}
			//System.out.println();
			out.write("\r\n".getBytes());
		}
		out.close();
	}
	//夹角余弦法的分子
	public double fenzi(int i,int j){
		
		double s = 0;
		for(int k = 0;k<64;k++){
			s = s+(list.get(i))[k]*(list.get(j))[k];
		}
		return s;
	}
	//夹角余弦法的分母
	public double fenmu(int i,int j){
		
		double s1 = 0;
		double s2 = 0;
		for(int k = 0;k<64;k++){
			s1 = s1+(list.get(i))[k]*(list.get(i))[k];
			s2 = s2+(list.get(j))[k]*(list.get(j))[k];
		}
		double s = Math.sqrt(s1)*Math.sqrt(s2);
		return s;
	}
	
	//对模糊相似矩阵进行多次平方得到模糊等价矩阵,并根据阈值得到截矩阵
	@Test
	public void matrix2() throws IOException{
		DecimalFormat df = new DecimalFormat("0.000");
		FileOutputStream out = new FileOutputStream("C:\\Users\\Administrator\\Desktop\\模糊等价矩阵.txt");
		
		for(int n = 0;n<16;n++){
			R2();
		}
		
		out.write("模糊等价矩阵:\r\n".getBytes());
		for(int a = 0;a<20;a++){
			for(int b = 0;b<a+1;b++){
				//System.out.print(df.format(matrix1[a][b])+"  ");
				out.write((df.format(matrix1[a][b])+"  ").getBytes());
			}
			//System.out.println();
			out.write("\r\n".getBytes());
		}
		
		//得到截矩阵
		//设置阈值
		double lamda = 0.65;
		for(int i = 0;i<20;i++){
			for(int j = 0;j<20;j++){
				if(matrix1[i][j] >= lamda){
					matrix3[i][j] = 1;
				}
				else{
					matrix3[i][j] = 0;
				}
			}
		}
		FileOutputStream out2 = new FileOutputStream("C:\\Users\\Administrator\\Desktop\\截矩阵.txt");
		out2.write("截矩阵:\r\n".getBytes());
		out2.write(("阈值为:"+lamda+"\r\n").getBytes());
		for(int a = 0;a<20;a++){
			for(int b = 0;b<a+1;b++){
				System.out.print(matrix3[a][b]+"  ");
				out2.write((matrix3[a][b]+"  ").getBytes());
			}
			System.out.println();
			out2.write("\r\n".getBytes());
		}
		out.close();
		out2.close();
	}
	
	
	//对模糊矩阵进行一次平方
	public void R2(){
		//DecimalFormat df = new DecimalFormat("0.000");
		
		for(int i = 0;i<20;i++){
			for(int j = 0;j<20;j++){
				matrix2[i][j] = multiply2(i,j);
			}
		}

		//matrix1 = matrix2;
		for(int a = 0;a<20;a++){
			for(int b = 0;b<20;b++){
				matrix1[a][b] = matrix2[a][b];
			}
		}
		
		/*for(int a = 0;a<20;a++){
			for(int b = 0;b<a+1;b++){
				System.out.print(df.format(matrix2[a][b])+"  ");
			}
			System.out.println();
		}*/
	}
	//前一个矩阵行与后一个矩阵列的合成
	public double multiply2(int i,int j){   //i为前一个矩阵的行数,j为后一个矩阵的列数
		
		double res = 0;
		for(int a = 0;a<20;a++){
			if(matrix1[i][a]>=matrix1[a][j]){
				if(matrix1[a][j]>res){
					res = matrix1[a][j];
				}
			}
			if(matrix1[i][a]<matrix1[a][j]){
				if(matrix1[i][a]>res){
					res = matrix1[i][a];
				}
			}
		}
		return res;
	}
	
	//判断密码子的类别
	public static void classify(String s){
		
		double[] x = new double[64];
		for(int i = 0;i<s.length()-2;i++){
			if(s.charAt(i)=='a'){   //第一个位置的判断  a
				if(s.charAt(i+1)=='a'){   //第二个位置的判断  a
					if(s.charAt(i+2)=='a'){    //第三个位置的判断
						x[0]++;
					}
					if(s.charAt(i+2)=='t'){    //第三个位置的判断
						x[1]++;
					}
					if(s.charAt(i+2)=='c'){    //第三个位置的判断
						x[2]++;
					}
					if(s.charAt(i+2)=='g'){    //第三个位置的判断
						x[3]++;
					}
				}
				if(s.charAt(i+1)=='t'){   //第二个位置的判断  t
					if(s.charAt(i+2)=='a'){    //第三个位置的判断
						x[4]++;
					}
					if(s.charAt(i+2)=='t'){    //第三个位置的判断
						x[5]++;
					}
					if(s.charAt(i+2)=='c'){    //第三个位置的判断
						x[6]++;
					}
					if(s.charAt(i+2)=='g'){    //第三个位置的判断
						x[7]++;
					}
				}
				if(s.charAt(i+1)=='c'){   //第二个位置的判断  c
					if(s.charAt(i+2)=='a'){    //第三个位置的判断
						x[8]++;
					}
					if(s.charAt(i+2)=='t'){    //第三个位置的判断
						x[9]++;
					}
					if(s.charAt(i+2)=='c'){    //第三个位置的判断
						x[10]++;
					}
					if(s.charAt(i+2)=='g'){    //第三个位置的判断
						x[11]++;
					}
				}
				if(s.charAt(i+1)=='g'){   //第二个位置的判断  g
					if(s.charAt(i+2)=='a'){    //第三个位置的判断
						x[12]++;
					}
					if(s.charAt(i+2)=='t'){    //第三个位置的判断
						x[13]++;
					}
					if(s.charAt(i+2)=='c'){    //第三个位置的判断
						x[14]++;
					}
					if(s.charAt(i+2)=='g'){    //第三个位置的判断
						x[15]++;
					}
				}
			}
			if(s.charAt(i)=='t'){   //第一个位置的判断  t
				if(s.charAt(i+1)=='a'){   //第二个位置的判断  a
					if(s.charAt(i+2)=='a'){    //第三个位置的判断
						x[16]++;
					}
					if(s.charAt(i+2)=='t'){    //第三个位置的判断
						x[17]++;
					}
					if(s.charAt(i+2)=='c'){    //第三个位置的判断
						x[18]++;
					}
					if(s.charAt(i+2)=='g'){    //第三个位置的判断
						x[19]++;
					}
				}
				if(s.charAt(i+1)=='t'){   //第二个位置的判断  t
					if(s.charAt(i+2)=='a'){    //第三个位置的判断
						x[20]++;
					}
					if(s.charAt(i+2)=='t'){    //第三个位置的判断
						x[21]++;
					}
					if(s.charAt(i+2)=='c'){    //第三个位置的判断
						x[22]++;
					}
					if(s.charAt(i+2)=='g'){    //第三个位置的判断
						x[23]++;
					}
				}
				if(s.charAt(i+1)=='c'){   //第二个位置的判断  c
					if(s.charAt(i+2)=='a'){    //第三个位置的判断
						x[24]++;
					}
					if(s.charAt(i+2)=='t'){    //第三个位置的判断
						x[25]++;
					}
					if(s.charAt(i+2)=='c'){    //第三个位置的判断
						x[26]++;
					}
					if(s.charAt(i+2)=='g'){    //第三个位置的判断
						x[27]++;
					}
				}
				if(s.charAt(i+1)=='g'){   //第二个位置的判断  g
					if(s.charAt(i+2)=='a'){    //第三个位置的判断
						x[28]++;
					}
					if(s.charAt(i+2)=='t'){    //第三个位置的判断
						x[29]++;
					}
					if(s.charAt(i+2)=='c'){    //第三个位置的判断
						x[30]++;
					}
					if(s.charAt(i+2)=='g'){    //第三个位置的判断
						x[31]++;
					}
				}
			}
			if(s.charAt(i)=='c'){   //第一个位置的判断  c
				if(s.charAt(i+1)=='a'){   //第二个位置的判断  a
					if(s.charAt(i+2)=='a'){    //第三个位置的判断
						x[32]++;
					}
					if(s.charAt(i+2)=='t'){    //第三个位置的判断
						x[33]++;
					}
					if(s.charAt(i+2)=='c'){    //第三个位置的判断
						x[34]++;
					}
					if(s.charAt(i+2)=='g'){    //第三个位置的判断
						x[35]++;
					}
				}
				if(s.charAt(i+1)=='t'){   //第二个位置的判断  t
					if(s.charAt(i+2)=='a'){    //第三个位置的判断
						x[36]++;
					}
					if(s.charAt(i+2)=='t'){    //第三个位置的判断
						x[37]++;
					}
					if(s.charAt(i+2)=='c'){    //第三个位置的判断
						x[38]++;
					}
					if(s.charAt(i+2)=='g'){    //第三个位置的判断
						x[39]++;
					}
				}
				if(s.charAt(i+1)=='c'){   //第二个位置的判断  c
					if(s.charAt(i+2)=='a'){    //第三个位置的判断
						x[40]++;
					}
					if(s.charAt(i+2)=='t'){    //第三个位置的判断
						x[41]++;
					}
					if(s.charAt(i+2)=='c'){    //第三个位置的判断
						x[42]++;
					}
					if(s.charAt(i+2)=='g'){    //第三个位置的判断
						x[43]++;
					}
				}
				if(s.charAt(i+1)=='g'){   //第二个位置的判断  g
					if(s.charAt(i+2)=='a'){    //第三个位置的判断
						x[44]++;
					}
					if(s.charAt(i+2)=='t'){    //第三个位置的判断
						x[45]++;
					}
					if(s.charAt(i+2)=='c'){    //第三个位置的判断
						x[46]++;
					}
					if(s.charAt(i+2)=='g'){    //第三个位置的判断
						x[47]++;
					}
				}
			}
			if(s.charAt(i)=='g'){   //第一个位置的判断  a
				if(s.charAt(i+1)=='a'){   //第二个位置的判断  a
					if(s.charAt(i+2)=='a'){    //第三个位置的判断
						x[48]++;
					}
					if(s.charAt(i+2)=='t'){    //第三个位置的判断
						x[49]++;
					}
					if(s.charAt(i+2)=='c'){    //第三个位置的判断
						x[50]++;
					}
					if(s.charAt(i+2)=='g'){    //第三个位置的判断
						x[51]++;
					}
				}
				if(s.charAt(i+1)=='t'){   //第二个位置的判断  t
					if(s.charAt(i+2)=='a'){    //第三个位置的判断
						x[52]++;
					}
					if(s.charAt(i+2)=='t'){    //第三个位置的判断
						x[53]++;
					}
					if(s.charAt(i+2)=='c'){    //第三个位置的判断
						x[54]++;
					}
					if(s.charAt(i+2)=='g'){    //第三个位置的判断
						x[55]++;
					}
				}
				if(s.charAt(i+1)=='c'){   //第二个位置的判断  c
					if(s.charAt(i+2)=='a'){    //第三个位置的判断
						x[56]++;
					}
					if(s.charAt(i+2)=='t'){    //第三个位置的判断
						x[57]++;
					}
					if(s.charAt(i+2)=='c'){    //第三个位置的判断
						x[58]++;
					}
					if(s.charAt(i+2)=='g'){    //第三个位置的判断
						x[59]++;
					}
				}
				if(s.charAt(i+1)=='g'){   //第二个位置的判断  g
					if(s.charAt(i+2)=='a'){    //第三个位置的判断
						x[60]++;
					}
					if(s.charAt(i+2)=='t'){    //第三个位置的判断
						x[61]++;
					}
					if(s.charAt(i+2)=='c'){    //第三个位置的判断
						x[62]++;
					}
					if(s.charAt(i+2)=='g'){    //第三个位置的判断
						x[63]++;
					}
				}
			}
		}
		for(int j = 0;j<64;j++){
			/*DecimalFormat df = new DecimalFormat("#.0000");  //设置为4位小数
			x[j] = Double.parseDouble(df.format(x[j]/(s.length()-2))); */
			x[j] = x[j]/(s.length()-2);
			//System.out.println(x[j]);
		}
		list.add(x);
	}
}

阅读更多
文章标签: 模糊聚类 java
个人分类: java
想对作者说点什么? 我来说一句

没有更多推荐了,返回首页

关闭
关闭
关闭