CMAR代码学习3 结合生成的classifier进行预测

最新推荐文章于 2023-04-15 22:24:48 发布
最新推荐文章于 2023-04-15 22:24:48 发布
阅读量380 收藏
点赞数
分类专栏： 论文准备
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/woshiwu6666/article/details/124803026
版权

学习

CMAR代码学习1 生成FP-tree挖掘规则icon-default.png?t=M4ADhttps://blog.csdn.net/woshiwu6666/article/details/124717377CMAR代码学习2 计算卡方值并利用CR-tree剪枝icon-default.png?t=M4ADhttps://blog.csdn.net/woshiwu6666/article/details/124790979

数据集一共有数据14条

训练集9条

测试接5条

在Evauator当中

// For each fold, it does training and testing
		for (int i = 0; i < k; i++) {
//				//Partitioning database 
			int posStart = i * absoluteRatio; // start position of testing set
			int posEnd = posStart + absoluteRatio; // end position of testing set
			if (i == (k - 1)) { // if last fold we adjust the size to include all the left-over sequences
				posEnd = dataset.getInstances().size(); // special case
			}

			// Split the dataset in two parts
			Dataset[] datasets = VirtualDataset.splitDatasetForKFold(dataset, posStart, posEnd);
			Dataset training = datasets[0];
			Dataset testing = datasets[1];

			if (DEBUGMODE) {
				System.out.println("===== KFOLD " + i + " =====");
				System.out.println(" k = " + k);
				System.out.println("  - Original dataset: " + dataset.getInstances().size() + " records.");
				System.out.println("  - Training part: " + training.getInstances().size() + " records.");
				System.out.println("  - Testing part: " + testing.getInstances().size() + " records.");
				System.out.println("===== RUNNING =====");
			}

			// for each classifier
			for (ClassificationAlgorithm algorithm : algorithms) {
				if (DEBUGMODE) {
					System.out.println("Running algorithm ... " + algorithm.getName());
//						System.out.println(datasets[0].getMapClassToFrequency());
//						System.out.println(datasets[1].getMapClassToFrequency());
				}
				// Train the classifier
				Classifier classifier = algorithm.trainAndCalculateStats(training);
				TrainingResults trainResults = new TrainingResults();
				trainResults.memory += algorithm.getTrainingMaxMemory();
				trainResults.runtime += algorithm.getTrainingTime();
				if (classifier instanceof RuleClassifier) {
					trainResults.avgRuleCount += ((RuleClassifier) classifier).getNumberRules() / (double) k;
				}

				// Run on training set
				ClassificationResults resultsOnTraining = new ClassificationResults();
				runOnInstancesAnUpdateResults(training, classifier, resultsOnTraining);

				// Run on testing set
				ClassificationResults resultsOnTesting = new ClassificationResults();
				runOnInstancesAnUpdateResults(testing, classifier, resultsOnTesting);

				/** Save results for this classifier for this dataset */
				allResults.addResults(resultsOnTraining, resultsOnTesting, trainResults);
			}
		}
		return allResults;
	}

 其中，该部分用于预测训练集

// Run on training set
				ClassificationResults resultsOnTraining = new ClassificationResults();
				runOnInstancesAnUpdateResults(training, classifier, resultsOnTraining);

这部分用于预测测试集

// Run on testing set
				ClassificationResults resultsOnTesting = new ClassificationResults();
				runOnInstancesAnUpdateResults(testing, classifier, resultsOnTesting);

调用runOnInstancesAnUpdateResults函数

 short predictedKlassIndex = classifier.predict(instance);//预测值
 short realKlassIndex = instance.getKlass();//真实值

private void runOnInstancesAnUpdateResults(Dataset dataset, Classifier classifier, ClassificationResults results) {
 		MemoryLogger.getInstance().reset();
		long thisRuntime = System.currentTimeMillis();

		for (Instance instance : dataset.getInstances()) {
			short predictedKlassIndex = classifier.predict(instance);
			short realKlassIndex = instance.getKlass();

			results.predictedClasses.add(predictedKlassIndex);
			results.matrix.add(realKlassIndex, predictedKlassIndex);
		}
		results.runtime += System.currentTimeMillis() - thisRuntime;
		MemoryLogger.getInstance().checkMemory();
		results.memory += MemoryLogger.getInstance().getMaxMemory();
	}

在ClassifierCMAR.java当中，重写predict函数

分类结果分成三类

  1. 没有matching rules
  2. 有多条matching rules，但只有onlyOneClass()
  3. 有多条matching rules，有多个class，需要调用groupRulesByKlass(matchingRules)对matchingrules分类
 @Override
    public short predict(Instance instance) {
        List<RuleCMAR> matchingRules = obtainallRulesForRecord(instance.getItems());

        // If no rules satisfy record, it cannot be performed any prediction
        if (matchingRules.isEmpty()) {
            return NOPREDICTION;
        }

        // If only one rule return class
        if (matchingRules.size() == 1) {
            return matchingRules.get(0).getKlass();
        }

        // If more than one rule but all have the same class return calss
        if (onlyOneClass(matchingRules)) {
            return matchingRules.get(0).getKlass();
        }

        // Group rules
        Map<Short, List<RuleCMAR>> ruleGroups = groupRulesByKlass(matchingRules);

        // Weighted Chi-Squared (WCS) Values for each group and
        // Select group with best WCS value and return associated class
        return getClassWithBestChiQuareValue(ruleGroups);    
     }

onlyOneClass(),判断matching rules是否只有一个class 

 /**
     * Check if in specified rules there are more than one class
     * 
     * @param rules to check if they have more class
     * @return true if there are only one class, false otherwise
     */
    private boolean onlyOneClass(List<RuleCMAR> rules) {
        short firstKlass = rules.get(0).getKlass();
        for (int i = 1; i < rules.size(); i++) {
            if (rules.get(i).getKlass() != firstKlass) {
                return false;
            }
        }
        return true;
    }

 groupRulesByKlass(matchingRules)，将不同class的matching rules进行分类

  /**
     * Forms groups of rules in function of its consequent
     * 
     * @param rules to be grouped by consequent
     * @return group of rules by klass
     */
    private Map<Short, List<RuleCMAR>> groupRulesByKlass(List<RuleCMAR> rules) {
    	Map<Short, List<RuleCMAR>> rulesByGroup = new HashMap<Short, List<RuleCMAR>>();
        for (RuleCMAR rule : rules) {
        	// Improved efficiency by Philippe
        	List<RuleCMAR> rulesForKlass = rulesByGroup.get(rule.getKlass());
            if (rulesForKlass == null) {
            	rulesForKlass = new ArrayList<RuleCMAR>();
                rulesByGroup.put(rule.getKlass(), rulesForKlass);
            }
            rulesForKlass.add(rule);
        }
        return rulesByGroup;
    }

以下是预测一条用于测试的例子

instance2 4 8 9 11 

通过黄色部分得到的matching rules 

0:[4] -> 12 #SUP: 2 #CONF: 0.6666666666666666 #CHISQUARE: 0.0
1:[2, 4] -> 11 #SUP: 1 #CONF: 1.0 #CHISQUARE: 2.2500000000000004
2:[2, 4, 8] -> 11 #SUP: 1 #CONF: 1.0 #CHISQUARE: 2.2500000000000004
3:[2, 4, 9] -> 11 #SUP: 1 #CONF: 1.0 #CHISQUARE: 2.2500000000000004
4:[2, 4, 8, 9] -> 11 #SUP: 1 #CONF: 1.0 #CHISQUARE: 2.2500000000000004
5:[4, 9] -> 12 #SUP: 1 #CONF: 0.5 #CHISQUARE: 0.32142857142857145
6:[4, 9] -> 11 #SUP: 1 #CONF: 0.5 #CHISQUARE: 0.32142857142857145
7:[4, 8, 9] -> 12 #SUP: 1 #CONF: 0.5 #CHISQUARE: 0.32142857142857145
8:[4, 8, 9] -> 11 #SUP: 1 #CONF: 0.5 #CHISQUARE: 0.32142857142857145
9:[4, 8] -> 12 #SUP: 2 #CONF: 0.6666666666666666 #CHISQUARE: 0.0
10:[2] -> 11 #SUP: 2 #CONF: 0.6666666666666666 #CHISQUARE: 2.25
11:[2, 9] -> 11 #SUP: 2 #CONF: 1.0 #CHISQUARE: 5.142857142857143
12:[2, 8, 9] -> 11 #SUP: 1 #CONF: 1.0 #CHISQUARE: 2.2500000000000004
13:[2, 8] -> 12 #SUP: 1 #CONF: 0.5 #CHISQUARE: 0.32142857142857145
14:[2, 8] -> 11 #SUP: 1 #CONF: 0.5 #CHISQUARE: 0.32142857142857145
15:[9] -> 12 #SUP: 3 #CONF: 0.6 #CHISQUARE: 0.22500000000000003
16:[8, 9] -> 12 #SUP: 2 #CONF: 0.6666666666666666 #CHISQUARE: 0.0
17:[8] -> 12 #SUP: 5 #CONF: 0.8333333333333334 #CHISQUARE: 2.25

调用 groupRulesByKlass(matchingRules)分类得到的结果，一个是分类为11，一个是分类为12

0:[2, 4] -> 11 #SUP: 1 #CONF: 1.0 #CHISQUARE: 2.2500000000000004
1:[2, 4, 8] -> 11 #SUP: 1 #CONF: 1.0 #CHISQUARE: 2.2500000000000004
2:[2, 4, 9] -> 11 #SUP: 1 #CONF: 1.0 #CHISQUARE: 2.2500000000000004
3:[2, 4, 8, 9] -> 11 #SUP: 1 #CONF: 1.0 #CHISQUARE: 2.2500000000000004
4:[4, 9] -> 11 #SUP: 1 #CONF: 0.5 #CHISQUARE: 0.32142857142857145
5:[4, 8, 9] -> 11 #SUP: 1 #CONF: 0.5 #CHISQUARE: 0.32142857142857145
6:[2] -> 11 #SUP: 2 #CONF: 0.6666666666666666 #CHISQUARE: 2.25
7:[2, 9] -> 11 #SUP: 2 #CONF: 1.0 #CHISQUARE: 5.142857142857143
8:[2, 8, 9] -> 11 #SUP: 1 #CONF: 1.0 #CHISQUARE: 2.2500000000000004
9:[2, 8] -> 11 #SUP: 1 #CONF: 0.5 #CHISQUARE: 0.32142857142857145 

0:[4] -> 12 #SUP: 2 #CONF: 0.6666666666666666 #CHISQUARE: 0.0
1:[4, 9] -> 12 #SUP: 1 #CONF: 0.5 #CHISQUARE: 0.32142857142857145
2:[4, 8, 9] -> 12 #SUP: 1 #CONF: 0.5 #CHISQUARE: 0.32142857142857145
3:[4, 8] -> 12 #SUP: 2 #CONF: 0.6666666666666666 #CHISQUARE: 0.0
4:[2, 8] -> 12 #SUP: 1 #CONF: 0.5 #CHISQUARE: 0.32142857142857145
5:[9] -> 12 #SUP: 3 #CONF: 0.6 #CHISQUARE: 0.22500000000000003
6:[8, 9] -> 12 #SUP: 2 #CONF: 0.6666666666666666 #CHISQUARE: 0.0
7:[8] -> 12 #SUP: 5 #CONF: 0.8333333333333334 #CHISQUARE: 2.25 

随后，分别对这两个组，计算累计卡方值

 

 然后，卡方值高的作为这个case的分类，因此选择11作为它的分类

key11 wcsValue17.015625000000004
key12 wcsValue0.8125714285714285

 随后调用results.predictedClasses.add(predictedKlassIndex);results.matrix.add(realKlassIndex, predictedKlassIndex);将结果放进ClassificationResults当中保存记录，方便计算结果
 

class ClassificationResults {
		ConfusionMatrix matrix = new ConfusionMatrix();
		List<Short> predictedClasses = new ArrayList<Short>();
		long runtime = 0l;
		Double memory = 0d;
	}
public ConfusionMatrix() {
		this.matrix = new TreeMap<Short, Map<Short, Long>>();
	}

matrix.add(realKlassIndex, predictedKlassIndex)，其中该函数有几个变量需要值的注意

predictedClasses：记录每条case的预测结果

allRealklasss：累计记录数据中实际出现有的class

allPredictedklasss:累计记录数据中实际预测的class

map与value::累计统计预测值的数量

nopredictions：统计预测错误的数量

correct：统计预测正确的数量

	/**
	 * Add both prediction and real value to the confusion matrix
	 * 
	 * @param realValue
	 * @param observedValue
	 */
	public void add(Short realValue, Short observedValue) {
		// ===============================================
		// PHILIPPE: I have optimized the code below... The maps was accessed numerous
		// times while it was unnecessary.
		// ======================================
		allRealklasss.add(realValue);
		allPredictedklasss.add(observedValue);

		Map<Short, Long> map = matrix.get(realValue);
		if (map == null) {
			map = new TreeMap<Short, Long>();
			matrix.put(realValue, map);
		}

		Long value = map.get(observedValue);
		if (value == null) {
			map.put(observedValue, 1l);
		} else {
			map.put(observedValue, value + 1);
		}

		this.total += 1;
		if (realValue.equals(Classifier.NOPREDICTION)) {
			nopredictions += 1;
		}

		if (realValue.equals(observedValue)) {
			this.correct += 1;
		}
	}

matrix用于统计预测值的分类情况

==========================================
matrix 
11{11=1}
==========================================
matrix 
11{11=1}12{12=1}
==========================================
matrix 
11{11=2}12{12=1}
==========================================
matrix 
11{11=2}12{12=2}
==========================================

在OverallResults.java当中

调用addResults(ClassificationResults resultsOnTraining, 
            ClassificationResults resultsOnTesting, 
            TrainingResults trainResults)保存结果

public void addResults(ClassificationResults resultsOnTraining, 
			ClassificationResults resultsOnTesting, 
			TrainingResults trainResults) {
		if(trainResults != null) {
			runtimeToTrain.add(trainResults.runtime);
			memoryToTrain.add(trainResults.memory);
			avgRuleCount.add(trainResults.avgRuleCount);
		}
		
		if(resultsOnTraining != null) {
			listMatrixOnTraining.add(resultsOnTraining.matrix);
			runtimeOnTraining.add(resultsOnTraining.runtime);
			memoryUsageOnTraining.add(resultsOnTraining.memory);
			
		}
		if(resultsOnTesting != null) {
			listMatrixOnTesting.add(resultsOnTesting.matrix);
			predictedClasseOnTesting.add(resultsOnTesting.predictedClasses);
			runtimeOnTesting.add(resultsOnTesting.runtime);
			memoryUsageOnTesting.add(resultsOnTesting.memory);
		}
	}

计算结果，并将结果保存到文本当中

MainTestCMAR_batch_kfold.java

其中

allResults.saveMetricsResultsToFile(forTrainingPath, onTrainingPath, onTrestingPath);//保存结果到txt当中

allResults.printStats()//输出结果到console当中


		// We run the experiment
		OverallResults allResults = experiment1.trainAndRunClassifiersKFold(algorithms, dataset, kFoldCount);

		// Save statistics about the execution to files (optional)
		String forTrainingPath = "outputReportForTraining.txt";
		String onTrainingPath = "outputReportOnTraining.txt";
		String onTrestingPath = "outputReportOnTesting.txt";
		allResults.saveMetricsResultsToFile(forTrainingPath, onTrainingPath, onTrestingPath);

		// Print statistics to the console (optional)
		allResults.printStats();
/**
	 * Save metrics to a file
	 * 
	 * @param metricsReportPath the file path
	 */
	public void saveMetricsResultsToFile(String toTrainpath, String onTrainingPath, String onTestingPath) {
		try {
			if(toTrainpath != null) {
				PrintWriter metricsWriter = new PrintWriter(toTrainpath, "UTF-8");
				metricsWriter.write(trainingMetricsToString(runtimeToTrain, memoryToTrain));
				metricsWriter.close();
			}
			
			if(onTrainingPath != null) {
				PrintWriter metricsWriter = new PrintWriter(onTrainingPath, "UTF-8");
				metricsWriter.write(metricsToString(listMatrixOnTraining, runtimeOnTraining, memoryUsageOnTraining));
				metricsWriter.close();
			}
			if(onTestingPath != null) {
				PrintWriter metricsWriter = new PrintWriter(onTestingPath, "UTF-8");
				metricsWriter.write(metricsToString(listMatrixOnTesting, runtimeOnTesting, memoryUsageOnTesting));
				metricsWriter.close();
			}
		} catch (FileNotFoundException | UnsupportedEncodingException e) {
			e.printStackTrace();
		}
	}

调用 metricsToString(List<ConfusionMatrix> listMatrix,List<Long> runtimes,List<Double> memoryUsages)函数，计算结果

private String metricsToString(List<ConfusionMatrix> listMatrix,
			List<Long> runtimes,
			List<Double> memoryUsages) {
		StringBuilder builder = new StringBuilder();
		//========
		builder.append("#NAME:\t");
		for(int i =0; i< algorithmCount; i++) {
			builder.append("\t" + names.get(i));
		}
		//========
		builder.append(System.lineSeparator());
		builder.append("#ACCURACY:");
		for(int i =0; i< algorithmCount; i++) {
			builder.append("\t" + df.format(listMatrix.get(i).getAccuracy()));
		}
		builder.append(System.lineSeparator());
		//========
		builder.append("#RECALL:");
		for(int i =0; i< algorithmCount; i++) {
			builder.append("\t" + df.format(listMatrix.get(i).getAverageRecall()));
		}
		builder.append(System.lineSeparator());
		//========
		builder.append("#PRECISION:");
		for(int i =0; i< algorithmCount; i++) {
			builder.append("\t" + df.format(listMatrix.get(i).getAveragePrecision()));
		}
		builder.append(System.lineSeparator());
		//========
		builder.append("#KAPPA:");
		for(int i =0; i< algorithmCount; i++) {
			builder.append("\t" + df.format(listMatrix.get(i).getKappa()));
		}
		builder.append(System.lineSeparator());
		//========
		builder.append("#FMICRO:");
		for(int i =0; i< algorithmCount; i++) {
			builder.append("\t" + df.format(listMatrix.get(i).getMicroFMeasure()));
		}
		builder.append(System.lineSeparator());
		//========x
		builder.append("#FMACRO:");
		for(int i =0; i< algorithmCount; i++) {
			builder.append("\t" + df.format(listMatrix.get(i).getMacroFMeasure()));
		}
		builder.append(System.lineSeparator());

		//========x
		builder.append("#TIMEms:");
		for(int i =0; i< algorithmCount; i++) {
			builder.append("\t" + runtimes.get(i));
		}
		builder.append(System.lineSeparator());
		//========
		builder.append("#MEMORYmb:");
		for(int i =0; i< algorithmCount; i++) {
			builder.append("\t" + df.format(memoryUsages.get(i)));
		}
		builder.append(System.lineSeparator());
		//========x
		builder.append("#NOPREDICTION:");
		for(int i =0; i< algorithmCount; i++) {
			builder.append("\t" + listMatrix.get(i).getNopredictions());
		}
		
		return builder.toString();
	}

woshiwu6666
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
CMAR代码学习2 计算卡方值并利用CR-tree剪枝
m0_54850825的博客
05-19 164
CMAR代码学习1 生成FP-tree挖掘规则[这里是图片001]https://blog.csdn.net//article/details/124717377 有一个java语法的知识点，通过赋值给属性，会自动调用toString方法 要特别注意的是，下面这个例子当中，要写成return “Animal [i=” + this.i + “, o=” + this.o +“,kafang=” +(this.kafang=(NUMBER_INSTANCES/3))+“]”;有this指针toString()
STM32学习笔记DMA代码理解
uiooooop的博客
10-17 1135
文章目录正点原子官方手册资料DMA了解具体配置自己的理解 正点原子官方手册资料 DMA了解   DMA，全称为：Direct Memory Access，即直接存储器访问，DMA 传输将数据从一个 地址空间复制到另外一个地址空间。当 CPU 初始化这个传输动作，传输动作本身是由 DMA 控制器 来实行和完成。典型的例子就是移动一个外部内存的区块到芯片内部更快的 内存区。像是这样的操作并没有让处理器工作拖延，反而可以被重新排程去处理其他的工 作。DMA 传输对于高效能嵌入式系统算法和网络是很重要的。DMA 传
python 多层感知器 sklearn.neural_network MLPClassifier.predict()函数
Dontla的博客
08-15 2434
官方doc: Signature: mlp.predict(X) Docstring: Predict using the multi-layer perceptron classifier Parameters ---------- X : {array-like, sparse matrix}, shape (n_samples, n_features) The input data...
机器学习算法之三——分类（四）
打死也不读博士
04-23 1992
1 SVM基本理论 支持向量机SVM（support vector mac），分类的基本思想是利用最大间隔分类，找到空间中的一个超平面，离这个超平面最近的点叫支持向量，点到超平面的距离叫间隔。如果要处理非线性问题，是通过核函数将特征向量映射到高维空间。从而变成线性可分的。 1.1几何间隔 我们假设超平面的判别式： 样本到超平面的几何间隔：，表示权重向量，b表示偏移向量，||...
Python 人工智能：6~10
最新发布
龙哥盟
04-15 3110
原文：Artificial Intelligence with Python 协议：CC BY-NC-SA 4.0 译者：飞龙 本文来自【ApacheCN 深度学习 译文集】，采用译后编辑（MTPE）流程来尽可能提升效率。 不要担心自己的形象，只关心如何实现目标。——《原则》，生活原则 2.3.c 6 集成学习的预测分析 在本章中，我们将学习集成学习以及如何将其用于预测分析。 在本章的最后，您将对这些主题有更好的理解： 决策树和决策树分类器 使用集成学习来学习模型 随机森林和极随机森林 预测的置信度估
sklearn的 fit 和 predict 使用
BigDeng_2014的专栏
08-10 1467
sklearn的 fit 和 predict 使用
CMAR基于多关联的分类算法
05-10
最终，CMAR利用多个强关联规则进行加权分析来进行分类。 #### 方法论 ##### FP-growth的扩展 CMAR通过扩展FP-growth算法来构建与类别分布相关的FP树。FP-growth是一种有效的频繁项集挖掘算法，它通过构建一棵特殊...
机器学习的分类、回归、聚类问题
王青宇的博客
03-19 7338
分类、回归问题都是监督学习，本质都是对输入做出预测，都要建立映射关系。分类问题输出的是物体所属的类别（瓜是好瓜吗），回归问题输出的是数值（瓜会卖到多少钱）。聚类是无监督学习 一.分类问题 分类问题输出的是物体所属的类别，即输出结果是：“好瓜/坏瓜”、“晴天/阴天/雨天”...，分类问题输出的值是定性的，目的是为了寻找决策边界。单一的分类方法主要包括：决策树、贝叶斯、人工神经网络、K-近邻、支持向量机和基于关联规则的分类等；另还有组合单一方法的集成学习算法，如Bagging、Boosting等。 1.决
分类和预测
seacean2000的专栏
01-20 4634
总述：分类和预测是数据挖掘当中梳理数据信息，提高有用数据浓度的常用操作，是数据挖掘的核心处理部分。 什么是分类，什么是预测 分类和预测需要注意的问题 使用决策树归纳分类 贝叶斯分类 基于规则的分类 向后传播分类 支持向量机 基于关联规则分析的分类 惰性学习法 其他的分类方法 预测 分类器或预测器的准确率和误差的度量 提高分类准确率的策略 如何选择合适的分类模型 ...
DecisionTreeClassifier的predict_proba(self,X)踩坑记
lighting
05-07 9226
DecisionTreeClassifier之predict_proba(self,X) 通过今日调试代码的过程发现自己对决策树代码的理解还是不够深刻，今天Mark一下。 问题： 按道理讲。调用DecisionTreeClassifier的predict_proba（X_test）方法可以得到每个样本属于不同类别的概率。并且概率和相加等于1.但是输出predict_proba（...
用Python开始机器学习（2：决策树分类算法）
热门推荐
lsldd的专栏
11-18 8万+
从这一章开始进入正式的算法学习。首先我们学习
机器学习入坑指南（五）：逻辑回归
acg32744的博客
09-26 186
一、逻辑回归简介 逻辑回归用于解决“二分类”问题，比如判断明天是晴是雨，判断一封邮件是否是垃圾邮件，判断肿瘤是否是恶性的等等。 让我们举个例子来说明为什么这类问题适合用逻辑回归而不是线性回归来解决。 假如我们想用肿瘤的大小判断它是否为恶性，根据样本，得到如下的线性回归模型： 看起来这条线拟合地并不是很令人满意，但似乎还是能够解决问题的，我们把输出的中值作为阈值，就可以得到正确的分类结果...
cs231n——assignment1： Q1: k-Nearest Neighbor classifier（手动复制版）
xieyi4650的博客
11-13 1830
作业文件地址下载（添加百度云链接） 作业一其他问题：（添加其他问题的博客地址） Training a Support Vector Machine（添加地址） Implement a Softmax classifier （添加地址） Two-Layer Neural Network （添加地址） Higher Level Representations: Image Features（添加地址）
Python sklearn库中决策树tree.DecisionTreeClassifier()函数参数介绍
li980828298的博客
04-17 6万+
Python sklearn库中决策树tree.DecisionTreeClassifier()函数参数介绍
caffe 用训练好的模型提取图片特征（使用自带classify.py和classifier.py）
woshilimengxi的博客
03-17 3580
原材料： 1）训练好的caffemodel 2)  定义网络结构的deploy.prototxt配置文件 3） 训练时使用的mean文件，在/cafferoot/python/classify.py的demo中，要求使用的是.npy格式的meanfile，如果我们手上有的是mean.binaryproto文件，则需要自己2完成转换：可以使用以下convert_mean.py来实现 #!/u
SGDClassifier() predict_proba()失败
TEDIST的博客
09-30 2501
今天在使用SGDClassifier()的时候发现，其无法使用predict_proba()这个方法，然后查阅Sklearn的中文文档发现如下解决方法： https://scikit-learn.org/stable/modules/generated/sklearn.linear_model.SGDClassifier.html#sklearn.linear_model.SGDClass...
tensorflow学习笔记十四：TF官方教程学习 tf.contrib.learn Quickstart
xiaopihaierletian的博客
03-16 1万+
TensorFlow高级API(tf.contrib.learn)及可视化工具TensorBoard的使用 一.TensorFlow高层次机器学习API (tf.contrib.learn) 1.tf.contrib.learn.datasets.base.load_csv_with_header 加载csv格式数据 2.tf.contrib.learn.DNNC
Scikit-learn——Decision Tree(Classifier)
空字符
01-08 3532
本文主要介绍一下sklearn中分类决策树的简单用法。决策树优点： 1.简单易于理解，能够可视化； 2.训练集规模不大，值得注意的是该模型不接受缺失值； 3.使用代价仅为训练样本数取对数； 4.既能够处理数值型数据集(numerical)也能够处理标签型(categorical)数据集 5.能够处理多输出问题； 6.能够用布尔逻辑来表示一种情况的决策过程，不像神经网络完全黑箱； 7.性
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值