2009-05-18 19:16:00 LOVESAP 阅读数 1262
  • R语言知识体系概览

    R语言是一门统计语言,主要用于数学建模、统计计算、数据处理、可视化 等几个方向,R语言天生就不同于其他的编程语言。R语言封装了各种基础学科的计算函数,我们在R语言编程的过程中只需要调用这些计算函数,就可以构建出面向不同领域、不同业务的、复杂的数学模型。掌握R语言的语法,仅仅是学习R语言的第一步,要学好R语言,需要你要具备基础学科能力(初等数学,高等数学,线性代数,离散数学,概率论,统计学) + 业务知识(金融,生物,互联网) + IT技术(R语法,R包,数据库,算法) 的结合。所以把眼光放长点,只有把自己的综合知识水平提升,你才真正地学好R语言。换句话说,一旦你学成了R语言,你将是不可被替代的。

    11246 人正在学习 去看看 张丹

 什么是离散型制造

jamessunrise | 19 十月, 2008 13:53

所谓离散型生产企业主要是指一大类机械加工企业。它们的基本生产特征是机器 ( 机床 ) 对工件外形的加工 , 再将不同的工件组装成具有某种功能的产品。由于机器和工件都是分立的 , 故称之为离散型生产方式。如汽车制造、飞机制造、电子企业和服装企业等。

所谓流程型生产企业是指被加工对像不间断地通过生产设备 , 如化工厂、炼油厂、水泥厂、发电厂等 , 这里基本的生产特征是通过一系列的加工装置使原材料进行规定的化学反应或物理变化 , 最终得到满意的产品。由于生产过程是 24 小时连续不断的 , 人们也称此类生产为过程型或连续型。

PS: 摘自百度知道

 

Reference from my another blog: http://jamessunrise.itpub.net/post/37844/472443

 

2019-10-09 15:19:07 nanshanfu 阅读数 109
  • R语言知识体系概览

    R语言是一门统计语言,主要用于数学建模、统计计算、数据处理、可视化 等几个方向,R语言天生就不同于其他的编程语言。R语言封装了各种基础学科的计算函数,我们在R语言编程的过程中只需要调用这些计算函数,就可以构建出面向不同领域、不同业务的、复杂的数学模型。掌握R语言的语法,仅仅是学习R语言的第一步,要学好R语言,需要你要具备基础学科能力(初等数学,高等数学,线性代数,离散数学,概率论,统计学) + 业务知识(金融,生物,互联网) + IT技术(R语法,R包,数据库,算法) 的结合。所以把眼光放长点,只有把自己的综合知识水平提升,你才真正地学好R语言。换句话说,一旦你学成了R语言,你将是不可被替代的。

    11246 人正在学习 去看看 张丹

传统离散型企业的IT架构之路

“有幸在The Open Group举办的主题为“数字化时代企业变革与人才转型”的高峰论坛作为嘉宾,分享了“离散型行业智能制造数据架构”的一些看法。主要从不同制造类型比较、智能制造及组件、数据架构分析及设计三个方面就我们在智能制造方面的一些探索和与会嘉宾进行了交流。”

 

 

 

智能制造倒逼IT架构规划

OSI是一家制造公司,而且是一个非常传统的制造公司,我们是做食品的,包括上游的农牧行业都有所涉及。对于像我们这样的制造公司,在五年以前,IT的架构相对而言都比较简单,整个的IT基本就是以ERP为核心的基本IT系统。但是近年来随着对制造行业的IT的能力提升,逐步地引入了大大小小的系统。IT已经走出了它的舒适区,很多的事情不仅仅是过去办公室的IT支持,涉及到生产、仓储等公司运营的方方面面,需要提供7x24小时的支持。整个IT在系统运维过程中就发现了一些问题。我们会发现IT这么多套系统,这些系统彼此之间的关系有时候大家都不知道。用户要上一个新的产品,在系统里设置完了,在相关系统中看不到。随着问题的积累,智能制造给人的感觉是越来越不智能:过去要做一些变动,直接打一个电话,下一个工作联系单就可以了,现在通过系统,不知道卡在哪,整个生产全部停滞。这个问题导致整个IT就成为公司业务的包袱,迫切需要变革。

由于业务的倒推,IT重新回来补课-企业的架构究竟应该怎么样? 因为IT并不是制造企业的主业,IT人员在公司中的比例相对也比较少。所以很多时候,我们都是采用了一些现有成熟的产品,把原来的ERP系统重构,把它的模块分解落地,变成一个小的功能,逐步逐步地把ERP虚化,跟用户接触的都是小的系统。我们的挑战是如果这些系统都是已有的,在可调整的范围是有限的情况下,如何适应整个公司的发展,如何构建这样企业架构。我们的重点就在数据,因为数据是企业最核心的东西,而且是贯穿企业的整个业务流。所以我分享的并不仅仅是数据架构,也是一个在数据驱动下的企业的架构,从数据的角度来看,在企业架构中系统之间是如何协同。

 

不同制造类型比较

通常来说,对于制造型企业,我们可能会分成两种,一种是流程型,一种是离散型。有些行业生来就具有这样流程型企业的特性,它所有的企业都是流程型的,比如化工行业。有一些比如说机械行业,绝大部分是离散型的。但是像我们这种行业,根据它的产品不同,我有可能是流程型的,也有可能是离散型的。​

流程型的供应商生产系统有一个统一的中控室,中控室已经把下面的每一个设备集成起来,生产管理是在中控室完成的。离散型的所有的加工都是在机台上完成的,集成度低,但工艺灵活。在智能制造的过程当中,离散型的柔性会很好,但对IT系统的要求也会更高。

智能制造其实是已经讲了很久的概念。一重工解释是“面向产品全生命周期,实现在泛感知条件下的信息化制造”。关键点第一是生命周期,在智能制造过程中,关注的是产品加工整体的生命周期,从研发开始一直到产品的结束。同时这是一个泛感知,所谓的泛感知就是整个生产工艺更具备智能性。通过一些智能手段,对整个生产过程进行及时地优化。

智能制造是一个很大的概念,它涵盖的系统会有很多。从工厂、车间和设备三个层级来看,智能制造所融合的不同的系统,有不一样的数据,不一样的系统的要求。​

 

数据架构分析及设计

目前最常见的是系统集成,一种是通过接口,或者是通过API的形式,还有一种是企业服务总线。对于这两种方法,各有利弊。

目前来说,我们对于数据架构面临的问题最根本的是缺乏一种统一的数据管理的战略和架构。因此,对于这个架构来说,我们希望是什么?

所以我们在实施的过程通过元数据,对于整个生产过程中的数据进行抽象,保证数据来源只有一个。并建立统一的主数据管理系统,一方面收集所有的核心数据,另一方面这些数据根据生命周期进行主动管理。画出数据流图,对于数据包含什么内容,来源是什,在什么情况下触发,流转的频率、方向,等等,进行可视化管理。

同时考虑到一个数据在两个维度上的分级管理。从水平方面,分成了三个层级。第一层级就是我的规格要求的数据,一般来说是从研发、设计和质量来的,那也就是某一个产品图纸、配方、技术参数、工艺、质量法规要求。这些是相对来说比较高的层次,是这个产品来最基本的要求。第二层级是把这些要求落地,第三层级是执行情况的反馈。很多时候,数据是在反馈和执行之间做流动,但问题积累到一定程度之后,可能会反馈到上面的要求层,需要对产品重新做设计和参数调整。在是垂直的方面,基于用户权限,和使用的位置,对于谁可以访问什么样的数据,什么样的数据可以下达到哪些系统或设备,进行管理。

我们要保证数据的管理和效率的统一,所以需要做一个平衡,基于业务流程来驱动,因为BPM本身就是基于业务流程进行管理,对于业务流程管理来说,它包含三种类型:系统和系统之间的对接、系统和人的对接、人和人的对接。从而以业务流程驱动数据在整个公司里面的流转,数据的统一分发。

从整体来说,我们保证数据是在一个统一的平台上,对于全公司全程可见。

作者:

 

 

姚凯

姚凯,IT总监,欧喜投资(中国)有限公司

高级工程师,二十余年IT从业经验,具有多个行业IT管理经验,有丰富的理论和实践经验。主持过多次公司的IT整合,IT战略规划和架构设计,及系统的选型和实施。参与编写《CIO新思维》,翻译《The Wolf of CIO》,《CCSP 认证考试指南》和《SIAM基于多供应商的服务集成和管理体系》等书。​​​​

2019-03-06 13:19:51 u010164507 阅读数 1617
  • R语言知识体系概览

    R语言是一门统计语言,主要用于数学建模、统计计算、数据处理、可视化 等几个方向,R语言天生就不同于其他的编程语言。R语言封装了各种基础学科的计算函数,我们在R语言编程的过程中只需要调用这些计算函数,就可以构建出面向不同领域、不同业务的、复杂的数学模型。掌握R语言的语法,仅仅是学习R语言的第一步,要学好R语言,需要你要具备基础学科能力(初等数学,高等数学,线性代数,离散数学,概率论,统计学) + 业务知识(金融,生物,互联网) + IT技术(R语法,R包,数据库,算法) 的结合。所以把眼光放长点,只有把自己的综合知识水平提升,你才真正地学好R语言。换句话说,一旦你学成了R语言,你将是不可被替代的。

    11246 人正在学习 去看看 张丹

简单概括,流程型与离散型有如下不同?

流程型制造使用配方或食谱。 离散制造使用物料清单(BOM)。 离散制造商顺着工艺路线进行组装,而流程制造商则多批量混合。 因此,离散制造商 - 包括按库存生产,按订单生产和组装订生产需要复杂周全的计划,调度和跟踪功能,以改善运营和盈利能力。

 

而具有批量或连续操作的流程型制造商依赖于复杂的跟踪和调配机制来保证高效的加工执行。

离散制造就是组装东西,制作精确的东西。 这些产品通常以单独定义的批次生产,工作中心的顺序跟随生产而变化。 因此,在离散制造中,产品通过使用相同的工艺路线或由相同操作者按顺序逐步加工制成。 基于生产订单和产品的离散制造经常从一个订单到另一个订单。

而流程制造是指您的产品需要完成一组流程,而每个流程都需要某些要求,因此,在规划和制定制造要求时,最好将每个流程与另一个流程分开。如果单独处理,则进行控制和维护。

 

流程型制造的东西不能进行分拆,从技术上讲,你可以将混合物从容器中取出并重新使用容器,但你不能从生产的成品中取出原料。这使得流程制造的过程基于配方。离散型制造商正在生产可能有螺钉,螺母,手柄等的成品,如果需要可以将其拆开并用于其他用途。在离散制造中,生产车间按照车间订单(计划)来制造某些东西。个别产品易于识别。在流程制造过程中,您无法分辨出一种产品与另一种产品之间的区别。

这两个不同制造领域之间的最大区别在于,离散制造的产物可以毫无困难地逆转,而对于流程制造而言,没有办法做到这一点。流程制造涉及可变成分,副产品和副产品,而离散制造则是标准零件和部件驱动。离散制造使用复杂多级BOM,而流程制造使用多个配方和公式。流程制造的必要条件是Lot Potency和Shelf Life,而离散制造价值序列号,ECN和组装。

流程型制造的特征在于生产方法,其在任何一个生产过程中或在类似产品的生产过程的实际处理中具有最小化的中断。但是,离散制造的特点是生产不同的物品,这些物品使用物料清单和工艺路线来确定成本和交货时间。

大多数加工业的特点是制造大量产品的行业,例如油漆,药品,饮料和食品,这些产品经常进行化学转化。另一方面,离散制造商生产或组装可识别为不同单元的组件或成品,例如汽车,能够被序列化或标签产品识别并且可评估为数量而不是重量或体积。

在流程工业中,我们没有学会做面向缺陷的制造,比如说如果你加工过多的染料,你可以放一些基础并修复它的方法

流程型是直接的,实时的控制。而在离散制造中,其事后统计分析可以得到持续改进。

 

2015-03-15 00:33:32 fansy1990 阅读数 3277
  • R语言知识体系概览

    R语言是一门统计语言,主要用于数学建模、统计计算、数据处理、可视化 等几个方向,R语言天生就不同于其他的编程语言。R语言封装了各种基础学科的计算函数,我们在R语言编程的过程中只需要调用这些计算函数,就可以构建出面向不同领域、不同业务的、复杂的数学模型。掌握R语言的语法,仅仅是学习R语言的第一步,要学好R语言,需要你要具备基础学科能力(初等数学,高等数学,线性代数,离散数学,概率论,统计学) + 业务知识(金融,生物,互联网) + IT技术(R语法,R包,数据库,算法) 的结合。所以把眼光放长点,只有把自己的综合知识水平提升,你才真正地学好R语言。换句话说,一旦你学成了R语言,你将是不可被替代的。

    11246 人正在学习 去看看 张丹

本篇代码可在 http://download.csdn.net/detail/fansy1990/8502323下载。

前篇《HotSpot关联规则算法(1)-- 挖掘离散型数据》分析了离散型数据的HotSpot关联规则,本篇分析离散型和连续型数据的HotSpot关联规则挖掘。

1. 首先看下数据格式(txt文档):

@attribute outlook {sunny, overcast, rainy}
@attribute temperature numeric
@attribute humidity numeric
@attribute windy {TRUE, FALSE}
@attribute play {yes, no}
sunny,85,85,FALSE,no
sunny,80,90,TRUE,no
overcast,83,86,FALSE,yes
rainy,70,96,FALSE,yes
rainy,68,80,FALSE,yes
rainy,65,70,TRUE,no
overcast,64,65,TRUE,yes
sunny,72,95,FALSE,no
sunny,69,70,FALSE,yes
rainy,75,80,FALSE,yes
sunny,75,70,TRUE,yes
overcast,72,90,TRUE,yes
overcast,81,75,FALSE,yes
rainy,71,91,TRUE,no
此数据参考weka自带数据weather.arff,而且数据格式,比如写上@attribute 等都是参考weka的数据格式来的。下面代码中使用的数据格式如上所述,其格式描述如下:1)前m行以@attribute开头,代码m个属性,其中最后一个为目标属性;2)如果属性是数值型,则在attribute后面空格跟属性名,再空格跟numeric;如果是离散型,那么attribute后面空格跟属性名,再空格使用大括号把离散值括起来,离散值用逗号分隔;3)目标属性必须是离散型的(关于目标属性应该一定要属于离散型的这点要求,其实只是我代码里面这样说而已,一般的HotSpot算法并没有这个要求。如果目标属性一定要求是连续型的,可以在lz代码基础上进行修改)。

2. 数据读取

《HotSpot关联规则算法(1)》中的数据读取是针对离散型的数据的,所以需要进行修改,这里修改后只针对离散型数据进行编码,连续型数据保持即可,同时还需设置一个布尔数组指明属性列属于离散型还是连续型。其读取代码如下所示:

while ((tempString = reader.readLine()) != null) {
				// 第一行数据是标题
				if (tempString.indexOf(HSUtils.FILEFORMAT) == 0) {

					String attr = "";
					String[] attrStates = null;
					if (tempString.contains("{")) {
						attr = tempString.substring(
								HSUtils.FILEFORMAT.length(),
								tempString.indexOf("{")).trim();
						attrStates = tempString.substring(
								tempString.indexOf("{") + 1,
								tempString.indexOf("}")).split(",");
						for (int i = 0; i < attrStates.length; i++) {
							attrStates[i] = attrStates[i].trim();
						}
						numericList.add(false);
						this.attributeStates.put(attr, attrStates);// 在这里添加即可
					} else {// numeric
						if (tempString.contains("numeric")) {
							attr = tempString.substring(
									HSUtils.FILEFORMAT.length(),
									tempString.indexOf("numeric")).trim();
							numericList.add(true);
						} else {
							// error 数据格式错误
							throw new Exception("数据格式错误,请检查!");
						}

					}
					attrList.add(attr);
					line++;

					continue;
				}
				if (flag) {
					this.attributes = new String[line];
					this.isNumeric = new Boolean[line];
					attrList.toArray(this.attributes);// 复制值到数组中
					numericList.toArray(this.isNumeric);
					flag = false;
				}
				String[] tempStrings = tempString.split(splitter);
				lists.add(strArr2IntArr(tempStrings));
			}
这里只贴了while循环里面的代码,这里的代码即针对前面描述的数据格式规则进行变量初始化(其实,这里使用List存储转换后的数据,一般是可以使用数组来存储的,把List的数据转为数组即可,这样在后面的操作中可以更快,如果要优化,可以从这方面入手)。

3.  HotSpot关联规则树的节点定义说明:

由于这里增加了连续型属性数据,所以针对单个节点需增加一个布尔型变量lessThan,用于指明是要大于或者小于该节点数据,同时stateIndex应该是一个数值了(当前节点的值),而不是离散型数据状态的下标了。

4. 算法伪代码(建树过程)

在算法伪代码中的计算潜在节点时,针对连续型变量使用不同的方法,在weka源码中使用方法:evaluateNumeric来进行判断。在lz的代码中此部分是完全参考源码中的代码的,不过有一点就是在调用evaluateNumeric这个算法后,会针对某一列进行排序,即一个二维数组按某列进行全局排序。这个方法在weka源码中是使用Instances的quickSort方法进行排序的(使用了递归,没仔细看)。这里lz则是直接把List转为二维数组然后进行排序的,其方法如下:

/**
	 * 根据attrIndex进行排序,attrIndex必须是numeric的 此方法可能需要优化
	 * List 使用数组是否更快? 可以考虑使用数组
	 * @param intData
	 * @param attrIndex
	 * @return
	 */
	private List<float[]> sortBasedOnAttr(List<float[]> intData, final int attrIndex) {
		
		float[][] tmpData = new float[intData.size()][];
		intData.toArray(tmpData);

		Arrays.sort(tmpData,new Comparator<float[]>(){
			@Override
			public int compare(float[] o1, float[] o2) {
				if(o1[attrIndex]==o2[attrIndex]){
					return 0;
				}
				return o1[attrIndex]>o2[attrIndex]?1:-1;
			}
			
		});
		List<float[]> returnList = new ArrayList<float[]>();
		for (int i = 0; i < tmpData.length; i++) {
			returnList.add(tmpData[i]);
		}
		return returnList;
	}
同时,在递归构建孩子节点时,生成节点规则时,针对数值型和离散型其生成方式也是不同的,如下:

double[] newSplitVals = splitVals.clone();
			byte[] newTests = tests.clone();
			newSplitVals[attrStateSup.getAttrIndex()] = attrStateSup
					.getStateIndex() + 1;
			newTests[attrStateSup.getAttrIndex()] = isNumeric[attrStateSup.getAttrIndex()]?
				attrStateSup.isLessThan()?(byte)1:(byte)3:(byte) 2;

			HotSpotHashKey key = new HotSpotHashKey(newSplitVals, newTests);
在递归构建孩子节点时,使用的子数据集的生成方式也需要进行调整,如下:

/**
	 * 获取和splitAttributeIndex相同下标的属性以及stateIndex的所有数据
	 * 
	 * @param intData
	 * @param splitAttributeIndex
	 * @param splitValue
	 * @return
	 */
	private List<float[]> getSubData(List<float[]> intData,
			int splitAttributeIndex, float splitValue,boolean lessThan) {
		List<float[]> subData = new ArrayList<float[]>();
		for (float[] d : intData) {
			if(isNumeric[splitAttributeIndex]){
				if(lessThan){
					if (d[splitAttributeIndex] <= splitValue) {
		                subData.add(d);
		            }
				}else{
					if (d[splitAttributeIndex] > splitValue) {
		                subData.add(d);
		            }
				}
			}else{
				if (d[splitAttributeIndex] == splitValue) {
					subData.add(d);
				}
			}
		}
		return subData;
	}

节点的toString 方法,用于打印HotSpot关联规则树

/**
	 * 格式化输出
	 */
	public String toString(){
		String tmp = HSUtils.isNumeric(splitAttrIndex)?this.lessThan?" <= ":" > ":" = ";
		String attrState = HSUtils.isNumeric(splitAttrIndex)?String.valueOf(this.attrStateIndex):
			HSUtils.getAttrState(splitAttrIndex, (int)attrStateIndex);
 		return HSUtils.getAttr(this.splitAttrIndex)+tmp
				+attrState
				+"  ("+HSUtils.formatPercent(this.support)+" ["+this.stateCount+"/"+this.allCount+"])";
	}

在打印关联规则树时,同样需要判断当前的属性是离散型还是连续型的。


代码输出为:

文件读取完成,且属性和属性的各种状态初始化完成!
属性outlook的状态:	[sunny-->0,overcast-->1,rainy-->2,]
属性temperature的状态:	[numeric]
属性humidity的状态:	[numeric]
属性windy的状态:	[TRUE-->0,FALSE-->1,]
属性play的状态:	[yes-->0,no-->1,]

规则树如下:

play = no  (35.71% [5/14])
|	temperature > 83.0  (100.00% [1/1])
|	humidity > 90.0  (66.67% [2/3])
|	|	temperature > 70.0  (100.00% [2/2])
|	|	humidity <= 95.0  (100.00% [2/2])



分享,成长,快乐

脚踏实地,专注

转载请注明blog地址:http://blog.csdn.net/fansy1990



2018-06-14 22:24:46 wotui1842 阅读数 6462
  • R语言知识体系概览

    R语言是一门统计语言,主要用于数学建模、统计计算、数据处理、可视化 等几个方向,R语言天生就不同于其他的编程语言。R语言封装了各种基础学科的计算函数,我们在R语言编程的过程中只需要调用这些计算函数,就可以构建出面向不同领域、不同业务的、复杂的数学模型。掌握R语言的语法,仅仅是学习R语言的第一步,要学好R语言,需要你要具备基础学科能力(初等数学,高等数学,线性代数,离散数学,概率论,统计学) + 业务知识(金融,生物,互联网) + IT技术(R语法,R包,数据库,算法) 的结合。所以把眼光放长点,只有把自己的综合知识水平提升,你才真正地学好R语言。换句话说,一旦你学成了R语言,你将是不可被替代的。

    11246 人正在学习 去看看 张丹

数据预处理是进行数据分析的基础环节,数据预处理质量的高低往往能够对实验结果产生很大的影响,现在UCI上的人口调查收入数据集为例,演示如何使用python对该数据集进行预处理。该数据集中每个样本同时包含离散型特征和连续型特征。在进行预处理之前,将原数据集中的训练集部分和测试集部分合并,剔除了包含空值的样本后剩余45222个样本,将标签“>50K”记为1,“<=50K”记为0,并剔除了与抽样有关的特征fnlwgt。

相关文件的百度云下载地址为 链接:https://pan.baidu.com/s/18B7FB-oWETlcLmoF2Gg9vQ 密码:g4nd

从数据格式说明文件中我们可以知道数据集中每个字段的含义,我们可以看到:

  1. 每个样本中包含13个特征和1个标签,其中8个离散型特征、5个连续型特征;
  2. 8个离散型特征分别为:workclass、education、marital-status、occupation、relationship、race、sex、native-country;
  3. 5个连续型特征分别为:age、education-num、capital-gain、capital-loss、hours-per-week

        使用sklearn.preprocessing模块,分别对样本中包含的离散型特征和连续型特征进行处理。

1 对连续型特征进行预处理

对连续型特征进行预处理,即对连续型特征进行标准化,一种常用的标准化方法是将特征缩放至给定的最小值和最大值之间,通常在0和1之间,可以使用MinMaxScaler类实现。

思路如下:将所有的连续型特征取出来放在一起进行标准化,要注意区分正向指标和负向指标

代码如下:

#-*-coding:utf-8-*-
"""
@author:taoshouzheng
@time:2018/6/13 20:55
@email:tsz1216@sina.com
"""

from sklearn.preprocessing import MinMaxScaler
import numpy as np

"""
输入:E:\Experiment\Classification_Experiment\data\data_5.txt
输出:
	E:\Experiment\Classification_Experiment\data\data_6.txt		对样本的连续型特征进行标准化的结果
	E:\Experiment\Classification_Experiment\data\data_7.txt		所有样本的离散型特征,用于后面的对离散型特征进行处理
对数据集中的连续型特征进行标准化并将结果保存到文件中,将数据集中所有的离散型特征取出保存到文件中
"""

with open('E:\Experiment\csdn blog\original_data.txt', 'r') as f_obj:

	lines = f_obj.readlines()		# 逐行读取
	con_feature = []		# 所有样本的离散特征
	dis_feature = []		# 所有样本的连续特征
	for line in lines:
		line = line.strip().split(',')		# 将字符串划分为列表

		# 每个样本的连续特征
		# 注意capital-loss(资本损失)为负向指标!
		line_con_feature = [line[0], line[3], line[9], '-' + line[10], line[11]]		# 取出连续特征,存放到列表中
		con_feature.append(line_con_feature)		# 将所有样本的连续特征放在一个列表中

		# 每个样本的离散特征
		line_dis_feature = [line[1], line[2], line[4], line[5], line[6], line[7], line[8], line[12]]
		dis_feature.append(line_dis_feature)		# 将所有样本的离散特征放在一个列表中

	# 将样本的连续特征标准化到[0,1]中
	con_feature_array = np.array(con_feature, dtype=np.int32)		# 将列表转化为数组
	min_max_scaler = MinMaxScaler()		# 创建MinMaxScaler类的实例
	con_feature_minmax = min_max_scaler.fit_transform(con_feature_array)		# 标准化过程
	np.savetxt(r'E:\Experiment\csdn blog\1.txt', con_feature_minmax, delimiter=',', fmt='%f')

	dis_feature_array = np.array(dis_feature)
	np.savetxt(r'E:\Experiment\csdn blog\2.txt', dis_feature_array, delimiter=',', fmt='%s')

	print('Finished!')

运行结果截图如下:


连续型特征标准化结果


数据集中所有样本的离散型特征

2 对离散型特征进行预处理

对离散型特征进行处理的思路如下:从上图所示的文件中读出样本的离散型特征,然后利用LabelEncoder将离散型特征的字符型取值转变成数值型取值,然后再利用OneHotEncoder将离散型特征的取值转换成独热编码形式。为了便于读者理解,将对离散型特征的预处理工作分为两步实现:

第一步:离散型特征取值数值化

#-*-coding:utf-8-*-
"""
@author:taoshouzheng
@time:2018/6/14 16:59
@email:tsz1216@sina.com
"""

import pandas as pd
from sklearn.preprocessing import LabelEncoder

"""
对离散特征进行独热编码
1)先将离散特征取值数值化
2)再对数值化的离散特征取值进行独热编码
"""

# 读取.txt数据,将其存放在DataFrame中
dis_feature = pd.read_table(r'E:\Experiment\csdn blog\2.txt',
							encoding='utf-8', delimiter=',', header=None)

# 定义列名
dis_feature.columns = ['workclass', 'education', 'marital-status', 'occupation',
					   'relationship','race', 'sex', 'native-country']

# 创建LableEncoder类的实例
le = LabelEncoder()

for col in dis_feature.columns:
	dis_feature[col] = le.fit_transform(dis_feature[col].values)		# 对每一列所对应的离散型特征进行编码

dis_feature.to_csv(r'E:\Experiment\csdn blog\3.txt', index=False, header=False, sep=',')		# 结果写入文件

print('Finished!')

结果截图如下:


用LabelEncoder对离散型特征的取值进行数值化

第二步:对数值型特征取值进行独热编码

#-*-coding:utf-8-*-
"""
@author:taoshouzheng
@time:2018/6/14 17:25
@email:tsz1216@sina.com
"""

import pandas as pd
import numpy as np
from sklearn.preprocessing import OneHotEncoder

# 使用pandas读取文件
dis_feature = pd.read_table(r'E:\Experiment\csdn blog\3.txt', encoding='utf-8',
					 delimiter=',', header=None)

dis_feature_array = dis_feature.values		# 将DataFrame的数据存入二维数组

a_dis = dis_feature_array.tolist()		# dataframe格式数据转化为列表

enc = OneHotEncoder()		# 创建OneHotEncoder类的实例

enc.fit(a_dis)		# 训练

b_dis = enc.transform(a_dis).toarray()		# 将独热编码结果放入数组中

# 将结果写入文件
np.savetxt(r'E:\Experiment\csdn blog\4.txt', b_dis, encoding='utf-8', delimiter=',', fmt='%d')

print('Finished!')

结果截图如下:


独热编码后的结果(太长,没有完全截取)

最后,将对离散型特征的处理结果和对连续型特征的处理结果放到一个文件中即可

完整的精简版代码就不发了,需要的私聊QQ:3408649893


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