本体匹配第一个项目：基于字符串的相关方法，wordnet的方法以及基于结构（出度和入度）的方法的本体匹配—Java代码

最新推荐文章于 2024-06-13 08:39:21 发布

周艾圆

最新推荐文章于 2024-06-13 08:39:21 发布

阅读量941

点赞数 2

分类专栏：本体匹配---语言处理文章标签：自然语言处理矩阵算法字符串 java

本文链接：https://blog.csdn.net/sillyclown/article/details/103979231

版权

本体匹配---语言处理专栏收录该内容

2 篇文章 0 订阅

订阅专栏

基于字符串，wordnet以及基于结构的本体匹配Java代码。项目名称 GMR（郭meng ran）-ontology parsing

package com.tylg.maintest;

Main类

package com.tylg.maintest;


public class Main {

	public static void main(String[] args) {
		OntologyParsing op = new OntologyParsing();			//构建本体模型对象
		String file1 = "D:\\eclipse\\ljw-ontology parsing\\File of ontology\\onto-101.rdf";
		String file2 = "D:\\eclipse\\ljw-ontology parsing\\File of ontology\\onto-101.rdf";
		VectorSpaceMatrix vsm = new VectorSpaceMatrix();
		System.out.println("我们要解析的文件是：" + file1);
		System.out.println("我们要解析的文件是：" + file2);
		/**
		 * double [][]classesAboutNGramLMATRIX, double [][]datatypeproperityAboutNGramLMATRIX, double [][]objectproperityAboutNGramLMATRIX
		 * 以上三个二维数组的内容都是相似度矩阵值，分别为两个本体class，dataproperity，objectproperity中各个元素关于NGramL的相似度
		 */
		double [][]classesAboutNGramLMATRIX = new double[parsingOfClassAboutSpecifiedFile(op, file1).length][parsingOfClassAboutSpecifiedFile(op, file2).length];
		classesAboutNGramLMATRIX = vsm.vectorSpaceMatrixOfNGramL(parsingOfClassAboutSpecifiedFile(op, file1), parsingOfClassAboutSpecifiedFile(op, file2), 3);
		double [][]datatypeproperityAboutNGramLMATRIX = new double[parsingOfDatatypeProperityAboutSpecifiedFile(op, file1).length][parsingOfDatatypeProperityAboutSpecifiedFile(op, file2).length];
		datatypeproperityAboutNGramLMATRIX = vsm.vectorSpaceMatrixOfNGramL(parsingOfDatatypeProperityAboutSpecifiedFile(op, file1), parsingOfDatatypeProperityAboutSpecifiedFile(op, file2), 3);
		double [][]objectproperityAboutNGramLMATRIX = new double[parsingOfObjectProperityAboutSpecifiedFile(op, file1).length][parsingOfObjectProperityAboutSpecifiedFile(op, file2).length];
		objectproperityAboutNGramLMATRIX = vsm.vectorSpaceMatrixOfNGramL(parsingOfObjectProperityAboutSpecifiedFile(op, file1), parsingOfObjectProperityAboutSpecifiedFile(op, file2), 3);
		/**
		 * 三个for循环单纯为了检验关于NGramL相似度矩阵的值，作用就是为了调试时打印输出
		 */
		System.out.println("\n*****************************\n*    关于NGramL的相似度矩阵         *\n*****************************");
		System.out.println("\n关于class的NGramL相似度矩阵如下：");
		for(int i = 0; i < classesAboutNGramLMATRIX.length; i++) {
			for(int j = 0; j < classesAboutNGramLMATRIX[0].length; j++) {
				System.out.print(classesAboutNGramLMATRIX[i][j] + "  ");
			}
			System.out.println();
		}
		System.out.println("\n关于datatypeproperity的NGramL相似度矩阵如下：");
		for(int i = 0; i < datatypeproperityAboutNGramLMATRIX.length; i++) {
			for(int j = 0; j < datatypeproperityAboutNGramLMATRIX[0].length; j++) {
				System.out.print(datatypeproperityAboutNGramLMATRIX[i][j] + "  ");
			}
			System.out.println();
		}
		System.out.println("\n关于objectproperity的NGramL相似度矩阵如下：");
		for(int i = 0; i < objectproperityAboutNGramLMATRIX.length; i++) {
			for(int j = 0; j < objectproperityAboutNGramLMATRIX[0].length; j++) {
				System.out.print(objectproperityAboutNGramLMATRIX[i][j] + "  ");
			}
			System.out.println();
		}
		
		/**
		 * double [][]classesAboutwuAndPalmerSimilarMATRIX, double [][]datatypeproperityAboutwuAndPalmerSimilarMATRIX, double [][]objectproperityAboutwuAndPalmerSimilarMATRIX
		 * 以上三个二维数组的内容都是相似度矩阵值，分别为两个本体class，dataproperity，objectproperity中各个元素关于wuAndPalmer的相似度
		 */
		
		double [][]classesAboutwuAndPalmerSimilarMATRIX = new double[parsingOfClassAboutSpecifiedFile(op, file1).length][parsingOfClassAboutSpecifiedFile(op, file2).length];
		classesAboutwuAndPalmerSimilarMATRIX = vsm.vectorSpaceMatrixOfwuAndPalmer(parsingOfClassAboutSpecifiedFile(op, file1), parsingOfClassAboutSpecifiedFile(op, file2));
		double [][]datatypeproperityAboutwuAndPalmerSimilarMATRIX = new double[parsingOfDatatypeProperityAboutSpecifiedFile(op, file1).length][parsingOfDatatypeProperityAboutSpecifiedFile(op, file2).length];
		datatypeproperityAboutwuAndPalmerSimilarMATRIX = vsm.vectorSpaceMatrixOfwuAndPalmer(parsingOfDatatypeProperityAboutSpecifiedFile(op, file1), parsingOfDatatypeProperityAboutSpecifiedFile(op, file2));
		double [][]objectproperityAboutwuAndPalmerSimilarMATRIX = new double[parsingOfObjectProperityAboutSpecifiedFile(op, file1).length][parsingOfObjectProperityAboutSpecifiedFile(op, file2).length];
		objectproperityAboutwuAndPalmerSimilarMATRIX = vsm.vectorSpaceMatrixOfwuAndPalmer(parsingOfObjectProperityAboutSpecifiedFile(op, file1), parsingOfObjectProperityAboutSpecifiedFile(op, file2));
		
		System.out.println("\n********************************\n*    关于wuAndPalmer的相似度矩阵         *\n********************************");
		System.out.println("\n关于class的wuAndPalmer相似度矩阵如下：");
		for(int i = 0; i < classesAboutwuAndPalmerSimilarMATRIX.length; i++) {
			for(int j = 0; j < classesAboutwuAndPalmerSimilarMATRIX[0].length; j++) {
				System.out.print(classesAboutwuAndPalmerSimilarMATRIX[i][j] + "  ");
			}
			System.out.println();
		}
		System.out.println("\n关于datatypeproperity的wuAndPalmer相似度矩阵如下：");
		for(int i = 0; i < datatypeproperityAboutwuAndPalmerSimilarMATRIX.length; i++) {
			for(int j = 0; j < datatypeproperityAboutwuAndPalmerSimilarMATRIX[0].length; j++) {
				System.out.print(datatypeproperityAboutwuAndPalmerSimilarMATRIX[i][j] + "  ");
			}
			System.out.println();
		}
		System.out.println("\n关于objectproperity的wuAndPalmer相似度矩阵如下：");
		for(int i = 0; i < objectproperityAboutwuAndPalmerSimilarMATRIX.length; i++) {
			for(int j = 0; j < objectproperityAboutwuAndPalmerSimilarMATRIX[0].length; j++) {
				System.out.print(objectproperityAboutwuAndPalmerSimilarMATRIX[i][j] + "  ");
			}
			System.out.println();
		}
	}
	
	
	
	
	public static String[] parsingOfObjectProperityAboutSpecifiedFile(OntologyParsing op, String file1) {
		int i3 = op.weGetObjectProperties(op.buildModel(file1)).length;		//本体模型以参数形式传入，获得关于DatatypeProperity的数组长度
		String []s3 = new String[i3];									//创建对应长度的数组
		s3 = op.weGetObjectProperties(op.buildModel(file1));				//是中存放的就是各个ObjectProperity
		return s3;
	}

	public static String[] parsingOfDatatypeProperityAboutSpecifiedFile(OntologyParsing op, String file1) {
		int i2 = op.weGetDatatypeProperities(op.buildModel(file1)).length;	//本体模型以参数形式传入，获得关于DatatypeProperity的数组长度
		String []s2 = new String[i2];									//创建对应长度的数组
		s2 = op.weGetDatatypeProperities(op.buildModel(file1));				//是中存放的就是各个DatatypeProperity
		return s2;
	}

	public static String[] parsingOfClassAboutSpecifiedFile(OntologyParsing op, String file1) {
		int i1 = op.weGetClasses(op.buildModel(file1)).length;	//本体模型以参数形式传入，获得关于Classes的数组长度
		String []s1 = new String[i1];						//创建对应长度的数组
		s1 = op.weGetClasses(op.buildModel(file1));				//是中存放的就是各个Class
		return s1;
	}

}

OntologyParsing类

package com.tylg.maintest;

/**
 * 本体解析出来的东西放入各自数组当中
 */
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.util.ArrayList;
import java.util.List;

import org.apache.jena.ontology.DatatypeProperty;
import org.apache.jena.ontology.ObjectProperty;
import org.apache.jena.ontology.OntClass;
import org.apache.jena.ontology.OntModel;
import org.apache.jena.ontology.OntModelSpec;
import org.apache.jena.rdf.model.ModelFactory;
import org.apache.jena.util.iterator.ExtendedIterator;

public class OntologyParsing {
	public static OntModel buildModel(String s) {
		OntModel ontModel = ModelFactory.createOntologyModel(OntModelSpec.OWL_MEM);
		try {
			ontModel.read(new FileInputStream(s), "");
		} catch (FileNotFoundException e1) {
			e1.printStackTrace();
		}
		return ontModel;
	}

	/**
	 * 
	 * @param ontModel为本体模型，是本体解析的基础
	 * @return 为一个一维数组，该数组存放的是本体中的Class，展现形式为字符串
	 *         该方法利用List集合先添加符合要求的Class，然后将其转化为对应长度的数组，以返回值类型返回
	 */
	public String[] weGetClasses(OntModel ontModel) {
		List<String> list = new ArrayList<>();
		ExtendedIterator exIter = ontModel.listClasses();
		int i1 = 0;
		while (exIter.hasNext()) {
			OntClass oc = (OntClass) exIter.next();
			if ((oc.getURI() != null) && (oc.getURI().toString().startsWith("http://oaei"))) {
				i1++;
				String s1 = oc.getURI() + "";
				String s2 = s1.substring(0, s1.indexOf("#"));
				String s3 = s1.substring(s2.length() + 1, s1.length());
				list.add(s3);
			}
		}
		String[] classes = (String[]) list.toArray(new String[i1]);
		return classes;
	}

	/**
	 * 
	 * @param ontModel为本体模型，是本体解析的基础
	 * @return 为一个一维数组，该数组存放的是本体中的DatatypeProperity，展现形式为字符串
	 *         该方法利用List集合先添加符合要求的DatatypeProperity，然后将其转化为对应长度的数组，以返回值类型返回
	 */
	public String[] weGetDatatypeProperities(OntModel ontModel) {
		List<String> list = new ArrayList<>();
		int i2 = 0;
		ExtendedIterator exIter1 = ontModel.listDatatypeProperties();
		while (exIter1.hasNext()) {
			DatatypeProperty oc = (DatatypeProperty) exIter1.next();
			if (oc.getURI() != null && (oc.getURI().toString().startsWith("http://oaei"))) {// 字符串截取判断
				i2++;
				String s1 = oc.getURI() + "";
				String s2 = s1.substring(0, s1.indexOf("#"));
				String s3 = s1.substring(s2.length() + 1, s1.length());
				list.add(s3);
			}
		}
		String[] datatypeproperities = (String[]) list.toArray(new String[i2]);
		return datatypeproperities;
	}

	/**
	 * 
	 * @param ontModel为本体模型，是本体解析的基础
	 * @return 为一个一维数组，该数组存放的是本体中的ObjectProperity，展现形式为字符串
	 *         该方法利用List集合先添加符合要求的ObjectProperity，然后将其转化为对应长度的数组，以返回值类型返回
	 */
	public String[] weGetObjectProperties(OntModel ontModel) {
		ExtendedIterator exIter2 = ontModel.listObjectProperties();
		int i3 = 0;
		List<String> list = new ArrayList<>();
		while (exIter2.hasNext()) {
			ObjectProperty oc = (ObjectProperty) exIter2.next();
			if (oc.getURI() != null && (oc.getURI().toString().startsWith("http://oaei"))) {
				i3++;
				String s1 = oc.getURI() + "";
				String s2 = s1.substring(0, s1.indexOf("#"));
				String s3 = s1.substring(s2.length() + 1, s1.length());
				list.add(s3);
			}
		}
		String[] objectProperities = (String[]) list.toArray(new String[i3]);
		return objectProperities;
	}

}

VectorSpaceMatrix类

package com.tylg.maintest;

import com.tylg.maintest.WaysOfSimilary;

/**
 * 计算相似度矩阵,传入的为两个字符串数组，返回值为相似度的double类型的值。
 * 
 * @author 郭梦冉
 */
public class VectorSpaceMatrix {
	/**
	 * 
	 * @param s1为字符串一维数组
	 * @param s2为字符串一维数组
	 * @return 返回类型为二维数组，该二维数组是关于NGramL的相似度矩阵
	 */
	public static double[][] vectorSpaceMatrixOfNGramL(String[] s1, String[] s2, int n) {
		int len1 = s1.length;
		int len2 = s2.length;
		double[][] result = new double[len1][len2];
		WaysOfSimilary wos = new WaysOfSimilary();
		for (int i = 0; i < len1; i++) {
			for (int j = 0; j < len2; j++) {
				result[i][j] = wos.NGramL(s1[i], s2[j], n);
			}
		}
		return result;
	}

	/**
	 * 
	 * @param s1为字符串一维数组
	 * @param s2为字符串一维数组
	 * @return 返回类型为二维数组，该二维数组是关于wuAndPalmer的相似度矩阵
	 */
	public static double[][] vectorSpaceMatrixOfwuAndPalmer(String[] s1, String[] s2) {
		int len1 = s1.length;
		int len2 = s2.length;
		double[][] result = new double[len1][len2];
		WaysOfSimilary wos = new WaysOfSimilary();
		for (int i = 0; i < len1; i++) {
			for (int j = 0; j < len2; j++) {
				result[i][j] = wos.wuAndPalmerWordSimilarity(s1[i], s2[j]);
			}
		}
		return result;
	}

}

WaysOfSimilary类

package com.tylg.maintest;

/**
 * 相关的相似度计算方法
 * @author 郭梦冉
 */
import java.util.HashMap;
import java.util.Iterator;
import java.util.Map;

import org.apache.lucene.search.spell.NGramDistance;

import com.tylg.math.MathTool;

import edu.sussex.nlp.jws.JWS;
import edu.sussex.nlp.jws.WuAndPalmer;

public class WaysOfSimilary {

	// WordNet安装路径选择（不要进入到最内层）
	private static String dir = "D:\\Wordnet-2.1\\WordNet";
	// WordNet版本为2.1版
	private static JWS ws = new JWS(dir, "2.1");
	// 变量声明
	private static WuAndPalmer wu = ws.getWuAndPalmer();

	/**
	 * 使用Wu和Palmer算法求相似度最大值；Wu和Palmer算法适当地考虑了概念的密度信息， 认为层次越深概念间的语义距离越小，相似度越大
	 * 使用WuAndPalmer计算两个字符串相似度最大值
	 */
	public static double wuAndPalmerWordSimilarity(String str1, String str2) {
		double sc = wu.max(str1, str2, "n");
		return MathTool.decimalType(sc);
	}

	/**
	 * n为1、2、3时的数值分别代表 1-gram, 2-gram, 3-gram
	 * 
	 * @param a
	 *            字符串1
	 * @param b
	 *            字符串2
	 * @param n
	 *            n个字符为一组进行切分
	 * @return 一个小数，反映了其NGramL的相似度
	 */
	public static double NGramL(String a, String b, int n) {
		NGramDistance ng = new NGramDistance(n);
		return MathTool.decimalType(ng.getDistance(a, b));
	}

}

package com.tylg.math

MathTool

package com.tylg.math;

import java.math.BigDecimal;

public class MathTool {
	public static double decimalType(double x) {
		BigDecimal b = new BigDecimal(x);
		double f = b.setScale(2, BigDecimal.ROUND_HALF_UP).doubleValue();
		return f;
	}
}

package com.tylg.out_in_degree;

In_degree类

package com.tylg.out_in_degree;
/**
 * 该类是计算入度大小的，txt文档表明了一定的层级关系
 * @author 郭梦冉
 *
 */

import java.io.BufferedReader;
import java.io.FileReader;
import java.io.IOException;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.Map;

public class In_degree {
	public static Map<String, Integer> calculationOfIn_degree(String filename) throws IOException {
		BufferedReader br = new BufferedReader(new FileReader(filename));
		ArrayList<String> arrayList = new ArrayList<String>();
		String sline; // sline中存放的为文档中一行
		while ((sline = br.readLine()) != null) {
			arrayList.add(sline); // arrayList中存放的是每一行的字符串
		}
		br.close();
		int lengthOfMap = arrayList.size(); // lengthOfMap用于统计入度集合的元素
		Map<String, Integer> map = new HashMap<String, Integer>();
		String[] strArray = arrayList.toArray(new String[lengthOfMap]); // 将list集合转化为字符串数组，每一个数组元素是文件中的一行
		String[] headOfOneLine = new String[lengthOfMap]; // headOfOneLine数组用于存储每行的首个元素
		/**
		 * 下面的for循环就是为了将每行按空格切分的第一个字符串存储进数组，进行入度初始化操作，该数组还将用于后面的索引查询功能
		 */
		int flag = 0; // 该标志位用于初始化map集合而进行标志的
		for (int i = 0; i < strArray.length; i++) {
			String[] strOfOneLine = strArray[i].split("	"); // 将每一行按Tab键进行切割
			headOfOneLine[i] = strOfOneLine[0]; // 将文件每行第一个字符串存储进headOfOneLine数组中
			map.put(headOfOneLine[i], flag); // 初始化map集合，将每行首个字符串添加进map集合中的键位置，而值位置初始化都为0
		}
		for (int i = 0; i < strArray.length; i++) {
			String[] strOfOneLine = strArray[i].split("	"); // 将每一行按Tab键进行切割
			for (int j = 1; j < strOfOneLine.length; j++) { // 对每一行的元素进行遍历
				if (map.containsKey(strOfOneLine[j])) {
					map.replace(strOfOneLine[j], map.get(strOfOneLine[j]) + 1);
				} else {
					map.put(strOfOneLine[j], 1);
				}

			}
		}

		return map;
	}

}

Out_degree类

package com.tylg.out_in_degree;
/**
 * 该类就是计算对应txt文档的出度大小的，txt文档表明了一定的层级关系 
 * @author 郭梦冉
 *
 */

import java.io.BufferedReader;
import java.io.FileNotFoundException;
import java.io.FileReader;
import java.io.IOException;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.Iterator;
import java.util.Map;

import org.apache.commons.math3.linear.RealMatrix;

public class Out_degree {
	public static Map<String, Integer> calculationOfOut_degree(String filename) throws IOException {		// 返回的一个map集合，其中键为一个个字符串，值为对应的出度
		BufferedReader br = new BufferedReader(new FileReader(filename));
		ArrayList<String> arrayList = new ArrayList<String>();
		String sline;		// sline中存放的为文档中一行
		while ((sline = br.readLine()) != null) {
			arrayList.add(sline);		// arrayList中存放的是每一行的字符串
		}		
		br.close();
		Iterator<String> iteratorOfArrayList = arrayList.iterator();
		Map<String, Integer> map = new HashMap<String, Integer>();		// 这个map集合中用于存放各个字符串的对应出度，其中键为一个个字符串，值为对应的出度
		while(iteratorOfArrayList.hasNext()) {
			String str = iteratorOfArrayList.next();
			String[] strArr = str.split("	");		// 按照Tab对每一行进行分割
			for(int i = 0; i < strArr.length; i++) {
				map.put(strArr[i], 0);
			}

		}
		String[] all = arrayList.toArray(new String[arrayList.size()]);
		for (String string : all) {
			String[] strArrOneLine = string.split("	");		// 按照Tab对每一行进行分割
			map.put(strArrOneLine[0], strArrOneLine.length - 1);
		}

		return map;
	}
}

package com.tylg.simrank;

MyMatrix类

package com.tylg.simrank;
/**
 * 定义属于自己的矩阵转换和计算方法 
 */
import org.apache.commons.math3.linear.Array2DRowRealMatrix;
import org.apache.commons.math3.linear.LUDecomposition;
import org.apache.commons.math3.linear.RealMatrix;

public class MyMatrix {
	// 把二维数组转化为矩阵，输入为一个double型的二维数组，返回的为
	public static RealMatrix arrayToMatrix(double [][]array) {
		RealMatrix rm = new Array2DRowRealMatrix(array);
		return rm;
	}
	
	// 把输入的矩阵进行转置处理，输入输出都为一个矩阵类
	public static RealMatrix transposedMatrix(RealMatrix rm) {
		RealMatrix rmtranspose = rm.transpose();
		return rmtranspose;
	}
	
	// 将两个矩阵进行相乘运算，输入为两个矩阵，输出为该两个可乘矩阵的乘积
	public  static RealMatrix multiplyMatrix(RealMatrix rm1, RealMatrix rm2) {
		RealMatrix rm = rm1.multiply(rm2);
		return rm;
	}
	
	// 将一个矩阵进行逆计算，输入为一个方阵，输出为一个方阵
	public static RealMatrix inverseMatrix(RealMatrix a) {
		RealMatrix result = new LUDecomposition(a).getSolver().getInverse();
		return result;
	}
	
	// 矩阵加法,输入为两个方阵，输出为一个方阵
	public static RealMatrix addMatrix(RealMatrix a, RealMatrix b) {
		RealMatrix result = a.add(b);
		return result;
	}
	
}

SimRank类

package com.tylg.simrank;

import java.io.BufferedReader;
import java.io.File;
import java.io.FileNotFoundException;
import java.io.FileReader;
import java.io.IOException;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.Map;

import org.apache.commons.math3.linear.RealMatrix;

import fr.inrialpes.exmo.ontosim.util.matrix.Matrix;

/**
 * 
 * @author 郭梦冉 通过输入的一个有父子关系节点的.txt的文本文档，形如：univ profA profB 
 * 														profA studentA
 *         												studentA univ 
 *         												profB studentB 
 *         												studentB profB 
 *         算得各节点间的相似度，输出也为一个文档，形如：
 *         univ profB:0.10803511296 studentB:0.02203058176 profA
 *         profB:0.36478881792 studentB:0.08159625216 profB profA:0.36478881792
 *         univ:0.10803511296 studentB:0.0642220032 studentA:0.03022258176
 *         studentA studentB:0.28216737792 profB:0.03022258176 studentB
 *         studentA:0.28216737792 profA:0.08159625216 profB:0.0642220032
 *         univ:0.02203058176
 */
public class SimRank {
	private static double C = 0.8; // C在此为一个阻尼系数，论文中常取为0.8
	private static int TIMES_OF_ITERATION = 3; // 定义矩阵迭代计算公式的迭代次数

	public static RealMatrix simMatrixOfSimRank(String filename) throws IOException {
		BufferedReader br = new BufferedReader(new FileReader(filename));
		String s;
		ArrayList<String> arrayList = new ArrayList<String>();
		while ((s = br.readLine()) != null) {
			arrayList.add(s); // arrayList中存放的是每一行的字符串
		}
		br.close();
		String[] str = (String[]) arrayList.toArray(new String[arrayList.size()]); // 将list集合转化为数组
		br.close();
		String[] codeName = new String[str.length]; // 用于存放每行当中首个字符串为父节点
		// Map<String, Integer> map = new HashMap<String, Integer>(); // 用于存储Q矩阵中转移节点的情况
		int flag = 1; // flag标志位是为了标志阵flagQ当中的相关关系：Q是转移概率矩阵，它的每一列和为1，如果从节点i可以转移到节点j，并且这样的节点i一共有n个，则𝑄𝑖,𝑗=1/𝑛
		int[][] flagQ = new int[str.length][str.length];
		for (int i = 0; i < str.length; i++) { // 遍历数组，长度等于文档的行数
			String[] line = str[i].split(" "); // 将每行的字符串都按照空格进行分割，并存储到相应的数组中
			codeName[i] = line[0]; // 拿到一个父节点序列存放在codeName数组中
		}

		/**
		 * 这一个双层for循环就是把flag位添加至Q的标志矩阵flagQ中
		 */
		for (int i = 0; i < str.length; i++) { // 遍历数组
			String[] line = str[i].split(" "); // 将每行的字符串都按照空格进行分割，并存储到相应的数组中
			int sizeOfline = line.length; // 获得每个数组的长度
			for (int j = 0; j < sizeOfline; j++) {
				int index = getIndex(codeName, line[j]);
				if ((index != -1) && (index != i)) {
					flagQ[index][i] += flag; // 把有节点关系的相应矩阵的位置加1，也就是那个flag=1
				}

			}

		}

		/**
		 * 对这个标志矩阵flagQ进行处理，转化成我们计算需要的转移矩阵Q中,二维数组的行数=数组名.length，列数=数组名[0].length
		 */
		int[] totalOfRow = new int[flagQ[0].length]; // 这个数组就是把对应数组的每列元素加在一块
		for (int i = 0; i < flagQ[0].length; i++) {
			for (int j = 0; j < flagQ.length; j++) {
				totalOfRow[i] += flagQ[j][i];
			}
		}

		/**
		 * 将totalOfRow[]数组中的元素当成分母，让flagQ矩阵中每列的每个元素除以对应的totalOfRow[]数组中的元素，最后得到的便是转移矩阵Q_
		 */
		double[][] Q_ = new double[flagQ.length][flagQ[0].length];
		for (int i = 0; i < flagQ[0].length; i++) {
			for (int j = 0; j < flagQ.length; j++) {
				if (totalOfRow[i] != 0) { // 避免出现除零错误
					Q_[j][i] = (double) flagQ[j][i] / totalOfRow[i];
				}
			}
		}

		RealMatrix Q = MyMatrix.arrayToMatrix(Q_); // 将数组类转化为矩阵类
		RealMatrix initial_S = diagonalMatrix(1 - C, flagQ.length);
		/**
		 * initial_S：表示一个最初的矩阵 Q：转移矩阵 C：阻尼系数 TIMES_OF_ITERATION：迭代次数
		 */
		RealMatrix final_S = iterationOfMatrix(initial_S, Q, C, TIMES_OF_ITERATION, flagQ.length);

		return final_S;
	}

	/**
	 * 
	 * @param initial_S:初始的矩阵
	 * @param q:转移矩阵
	 * @param c2:阻尼系数
	 * @param time:迭代次数
	 * @return 我们所需要的在指定迭代次数后的SimRank节点相似度矩阵
	 */

	private static RealMatrix iterationOfMatrix(RealMatrix initial_S, RealMatrix Q, double c2, int timeOfIteration,
			int len) {
		RealMatrix midMatrix = initial_S;
		double[][] c_ = new double[len][len];
		/**
		 * 该for循环就是为了让常数c2与矩阵相乘，而先生成一个对角矩阵，对角元素为常数c2
		 */
		for (int i = 0; i < len; i++) {
			c_[i][i] = c2;
		}
		RealMatrix C_Matrix = MyMatrix.arrayToMatrix(c_); // 对角元素为c2的对角矩阵C_Matrix
		/**
		 * 该for循环就是通过simrank的矩阵迭代公式算出指定迭代次数后的相似度矩阵
		 */
		for (int i = 0; i < timeOfIteration; i++) {
			midMatrix = MyMatrix.addMatrix(MyMatrix.multiplyMatrix(
					MyMatrix.multiplyMatrix(MyMatrix.multiplyMatrix(C_Matrix, MyMatrix.transposedMatrix(Q)), midMatrix),
					Q), initial_S);

		}
		RealMatrix finalMatrix = midMatrix;
		return finalMatrix;
	}

	/**
	 * 
	 * @param d：对角线上的数值大小，在此位一个浮点数
	 * @param length：该方阵的长与宽的大小，为一个整数
	 * @return 返回的为一个矩阵，这个矩阵就是由二维数组转化的
	 */
	private static RealMatrix diagonalMatrix(double d, int length) {
		double[][] A = new double[length][length];
		for (int i = 0; i < length; i++) {
			A[i][i] = d;
		}
		return MyMatrix.arrayToMatrix(A);
	}

	/**
	 * 
	 * @param codeName
	 *            一个存父节点的数组
	 * @param string
	 *            被查找的字符串
	 * @return 相应的索引位置
	 */
	public static int getIndex(String[] codeName, String string) {
		for (int i = 0; i < codeName.length; i++) {
			if (string.equals(codeName[i])) {
				return i; // 找到就返回相应的下标范围是（0 ～ codeName.length-1）
			}
		}
		return -1;
	}
}

Test类

package com.tylg.simrank;

import java.io.IOException;
import java.util.HashMap;
import java.util.Map;


import com.tylg.out_in_degree.In_degree;
import com.tylg.out_in_degree.Out_degree;

public class Test {

	public static void main(String[] args) throws IOException {		
		Map<String, Integer>map1 = Out_degree.calculationOfOut_degree("test1");
		System.out.print("出度为：");
		System.out.println(map1);
		Map<String, Integer>map2 = In_degree.calculationOfIn_degree("test1");
		System.out.print("入度为：");
		System.out.println(map2);

	}
}

周艾圆

关注

2
点赞
踩
7

收藏

觉得还不错? 一键收藏
5
评论
本体匹配第一个项目：基于字符串的相关方法，wordnet的方法以及基于结构（出度和入度）的方法的本体匹配—Java代码

基于字符串，wordnet以及基于结构的本体匹配Java代码。项目名称 ljw-ontology parsingpackage com.tylg.maintest;Main类package com.tylg.maintest;public class Main { public static void main(String[] args) { OntologyParsing...
复制链接

扫一扫