精华内容
下载资源
问答
  • 本文文字及图片来源于网络,仅供学习、交流使用,不具有任何商业用途,如有问题请及时联系我们以作处理。以下文章来源于数据杂论,作者:Wpc7113Python 数据分析入门案例讲解...也就是使得数据的...

    本文的文字及图片来源于网络,仅供学习、交流使用,不具有任何商业用途,如有问题请及时联系我们以作处理。

    以下文章来源于数据杂论,作者:Wpc7113

    Python 数据分析入门案例讲解

    https://www.bilibili.com/video/BV18f4y1i7q9/

    1.标准化:去均值,方差规模化

    Standardization标准化:将特征数据的分布调整成标准正态分布,也叫高斯分布,也就是使得数据的均值为0,方差为1.

    标准化的原因在于如果有些特征的方差过大,则会主导目标函数从而使参数估计器无法正确地去学习其他特征。

    标准化的过程为两步:去均值的中心化(均值变为0);方差的规模化(方差变为1)。

    from sklearn importpreprocessingfrom sklearn.datasets importload_iris

    iris=load_iris()

    X, y=iris.data, iris.target'''标准变换'''scaler=preprocessing.StandardScaler().fit(X)

    x_scaler=scaler.transform(X)

    2. 最小-最大规范化

    最小-最大规范化对原始数据进行线性变换,变换到[0,1]区间(也可以是其他固定最小最大值的区间)

    min_max_scaler =preprocessing.MinMaxScaler()

    x_train_minmax= min_max_scaler.fit_transform(X)

    3.MaxAbsScaler

    max_abs_scaler =preprocessing.MaxAbsScaler()

    x_train_maxabs= max_abs_scaler.fit_transform(X)

    4.RobustScaler:带有outlier的数据的标准化

    transformer =preprocessing.RobustScaler().fit(X)

    x_robust_scaler=transformer.transform(X)

    5.QuantileTransformer 分位数变换

    quantile_transformer = preprocessing.QuantileTransformer(random_state=0)

    X_train_trans= quantile_transformer.fit_transform(X)

    6.Box-Cox

    Box-Cox变换是Box和Cox在1964年提出的一种广义幂变换方法,是统计建模中常用的一种数据变换,用于连续的响应变量不满足正态分布的情况。Box-Cox变换之后,可以一定程度上减小不可观测的误差和预测变量的相关性。Box-Cox变换的主要特点是引入一个参数,通过数据本身估计该参数进而确定应采取的数据变换形式,Box-Cox变换可以明显地改善数据的正态性、对称性和方差相等性,对许多实际数据都是行之有效。变化方式如下:

    pt = preprocessing.PowerTransformer(method='box-cox', standardize=False)

    pt.fit_transform(X)

    7.规范化(Normalization)

    规范化是将不同变化范围的值映射到相同的固定范围,常见的是[0,1],此时也称为归一化。

    X_normalized = preprocessing.normalize(X, norm='l2')

    8.独热编码

    enc = preprocessing.OneHotEncoder(categories='auto')

    enc.fit(y.reshape(-1,1))

    y_one_hot=enc.transform(y.reshape(-1,1))

    y_one_hot.toarray()

    9.Binarizer二值化

    binarizer = preprocessing.Binarizer(threshold=1.1)

    binarizer.fit(X)

    binarizer.transform(X)

    10.多项式变换

    poly =preprocessing.PolynomialFeatures(2)

    poly.fit_transform(X)

    11.自定义变换

    transformer = preprocessing.FunctionTransformer(np.log1p, validate=True)

    transformer.fit(X)

    log1p_x=transformer.transform(X)

    展开全文
  • 集合常见的方法整理

    2020-12-02 13:41:33
    调用 Add 方法,添加单个数据 括号中是所需添加的数据 例:arrayList.Add(100); 调用AddRange,添加一次性添加多个数据到集合 括号中是所需添加的数据 例:int[] nums = { 1, 2, 3, 4, 5, 6, 7, 8, 9, 0 }; ...

    在结尾追加数据

    1. 调用 Add 方法,添加单个数据 括号中是所需添加的数据

    例:arrayList.Add(100);

    1. 调用AddRange,添加一次性添加多个数据到集合 括号中是所需添加的数据

    例:int[] nums = { 1, 2, 3, 4, 5, 6, 7, 8, 9, 0 };
    ArrayList arrayList = new ArrayList();
    arrayList.AddRange(nums);

                     在集合中间插入数据
    

    1.调用用 Insert 方法 在集合中间插入单个数据,

    例:ArrayList arrayList = new ArrayList();
    arrayList.Add(100); arrayList.Add(200);
    arrayList.Add(300); arrayList.Insert(1, “哈哈”);
    在索引为1 处插入数据

    2.调用 InsertRange 方法 在集合中间插入多个数据

                  根据索引进行删除 
    

    1.RemoveAt(索引值) 删除对应索引值

    2.Remove 方法,根据数据进行删除

    该方法会遍历集合,并找到第一个与 obj 参数匹配的数据,将其删除。

    如果集合中有多个数 据符合删除的要求,只将第一个数据删除.

    如果没有找到与 obj 相同的数据,那么不删除任 何数据.

    1. RemoveRange,可以删除多个数据

                         判断集合中是否存在某个数据 
      

    Contains ( 类型 item ) 该方法在集合中判断是否存在 item 这个数据,

    如果存在就返回一个 true,否则返回 false

                       查询集合中某个元素第一次出现的索引值
    

    IndexOf 方法:当集合中有多个某元素时,可以使用 IndexOf 方法返回该元素第一次出现的索引

                                其他的方法 
    

    Clear 方法:该方法可以清空集合中所有数据,使其 Count 为 0

    Sort 方法:该方法可以将集合中的数据进行排序

    ToArray 方法:该方法将集合转化为 object 数组

    展开全文
  • 本文比较了用于数据准备几种方法,它们分别是提取-变换-加载批处理(ETL)、流式获取和数据整理。本文还讨论了数据准备如何与可视化分析相关联,以及不同用户角色(如数据科学家或业务分析人员)应如何共同构建...

    原创 2017-04-27 Kai Wähner
    翻译|谢旭
    审校|张卫滨
    本文比较了用于数据准备的几种方法,它们分别是提取-变换-加载批处理(ETL)、流式获取和数据整理。本文还讨论了数据准备如何与可视化分析相关联,以及不同用户角色(如数据科学家或业务分析人员)应如何共同构建分析模型的最佳实践。
    要点
    ● 在常见的机器学习/深度学习项目里,数据准备占去整个分析管道的60%到80%。
    ● 市场上有各种用于数据清洗和特征工程的编程语言、框架和工具。它们之间的功能有重叠,也各有权衡。
    ● 数据整理是数据预处理的重要扩展。它最适合在可视化分析工具中使用,这能够避免分析流程被打断。
    ● 可视化分析工具与开源数据科学组件之间,如R、Python、KNIME、RapidMiner互为补充。
    ● 避免过多地使用组件能够加速数据科学项目。因此,在数据准备步骤中利用流式获取框架或流式分析产品会是一个不错的选择。
    机器学习和深度学习项目在大多数企业中变得越来越重要。一个完整的项目流程包括数据准备(data preparation)、构建分析模型以及部署至生产环境。该流程是一个洞察-行动-循环(insights-action-loop),此循环能不断地改进分析模型。Forrester把这个完整的流程和其背后的平台称为洞察平台(Insights Platform)。
    当你打算使用机器学习或深度学习技术来构建分析模型时,一个重要的任务是集成并通过各种数据源来准备数据集,这些数据源包括比如文件、数据库、大数据存储、传感器或社交网络等等。此步骤可占整个分析项目的80%。
    本文比较了用于数据准备的几种方法,它们分别是提取-变换-加载(extract-transform-load,ETL)批处理、流式获取(streaming ingestion)和数据整理(data wrangling)。同时借助于先进的分析技术和开源框架(如R、Apache Spark、KNIME、RapidMiner),讨论了各种不同的选择及其折中。本文还讨论了数据准备如何与可视化分析相关联,以及不同用户角色(如数据科学家或业务分析人员)应如何共同构建分析模型的最佳实践。

    数据准备=数据清洗(Data Cleansing)+特征工程(Feature Engineering)

    数据准备是数据科学的核心。它包括数据清洗和特征工程。另外领域知识(domain knowledge)也非常重要,它有助于获得好的结果。数据准备不能完全自动化,至少在初始阶段不能。通常,数据准备占去整个分析管道(流程)的60%到80%。但是,为了使机器学习算法在数据集上获得最优的精确性,数据准备必不可少。
    数据清洗可使数据获得用于分析的正确形状(shape)和质量(quality)。它包括了许多不同的功能,例如:
    ● 基本功能(选择、过滤、去重、…)
    ● 采样(平衡(balanced)、分层(stratified)、…)
    ● 数据分配(创建训练+验证+测试数据集、…)
    ● 变换(归一化、标准化、缩放、pivoting、…)
    ● 分箱(Binning)(基于计数、将缺失值作为其自己的组处理、…)
    ● 数据替换(剪切(cutting)、分割(splitting)、合并、…))
    ● 加权与选择(属性加权、自动优化、…)
    ● 属性生成(ID生成、…)
    ● 数据填补(imputation)(使用统计算法替换缺失的观察值)
    特征工程会为分析选取正确的属性。我们需要借助数据的领域知识来选取或创建属性,这些属性能使机器学习算法正确地工作。特征工程过程包括:
    ● 头脑风暴或特征测试
    ● 特征选择
    ● 验证这些特征如何与模型配合使用
    ● 如果需要,改进特征
    ● 回到头脑风暴/创建更多的特征,直到工作完成
    请注意,特征工程已是建模(构建分析模型)步骤里的一部分,但它也利用数据准备这一功能(例如提取字符串的某些部分)。
    数据清洗和特征工程是数据准备的一部分,也是机器学习和深度学习应用的基础。这二者并不是那么容易,都需要花费功夫。
    数据准备会出现在分析项目的不同阶段:
    ● 数据预处理:从数据源获取数据之后直接处理数据。通常由开发人员或数据科学家实现,它包括初始转换、聚合(aggregation)和数据清洗。此步骤在数据的交互式分析开始之前完成。它只执行一次。
    ● 数据整理:在交互式数据分析和建模期间准备数据。通常由数据科学家或业务分析师完成,以便更改数据集和特征工程的视图。此步骤会迭代更改数据集的形状,直到它能很好地查找洞察或构建良好的分析模型
    不可或缺的数据预处理和数据整理
    让我们看一看典型的用于模型构建的分析流程:
    1. 数据访问
    2. 数据预处理
    3. 探索性数据分析(Exploratory Data Analysis)(EDA)
    4. 模型构建
    5. 模型验证
    6. 模型执行
    7. 部署
    步骤2的重点是在构建分析模型之前进行的数据预处理,而数据整理则用于步骤3和步骤4(在分析数据和构建模型时,数据整理允许交互式调整数据集)。注意,这三个步骤(2、3、4)都可以包括数据清洗和特征工程。
    以下截图是“数据准备”、“数据预处理”和“数据整理”这几个术语的Google搜索趋势。可以看出,数据整理受到了越来越多的关注:
    这里写图片描述
    图1:“数据准备”、“数据预处理”和“数据整理”的Google搜索趋势
    “inline数据整理”(inline data wrangling)是“数据整理”的一种特殊形式。在inline数据整理里,你可以利用可视化分析工具。这些工具不仅能用于可视化和模型构建,而且还能用于直接交互式整理。inline数据整理有巨大的优势,如下图所示:
    这里写图片描述
    图2:解耦数据预处理(decoupled data preprocessing)与inline数据整理的比较
    分析管道中的数据预处理和数据整理步骤通常由不同类型的用户完成。以下是参与分析项目的各种用户角色:
    ● 业务分析师:具有特定领域知识的商业/行业专家
    ● 数据科学家:数学、统计与编程(数据科学/脚本编写)专家;能够编写底层代码或使用更上层的工具
    ● 平民数据科学家(Citizen Data Scientist):类似于数据科学家,但处于更上层;需要使用更上层的工具而非编写代码;取决于工具的易用性,相关工作甚至可以由业务分析师来完成
    ● 开发者:软件开发专家(企业应用程序)
    这些用户必须密切合作,以便在数据科学项目中取得成功(另见“如何避免分析中的反模式:机器学习的三个要点”,这篇文章能帮你更好地了解这些用户角色)。
    虽然本文重点是介绍数据准备,但一图胜千言,并且人类只能解释直观可见的东西而非那些复杂的非结构化数据集,因此了解数据准备与可视化分析的关系也非常重要。有关更多细节,请参阅文章为什么应该使用可视化分析来做出更好的决策。目前主要的可视化分析工具有Qlik、Tableau和TIBCO Spotfire。
    那么可视化分析是如何与数据整理相关联的呢?RITO研究公司的首席分析师说,“让分析师停下他们手里正在进行的工作,而去切换到另一个工具是令人发狂的。这破坏了他们的工作流程。 他们不得不返回重拾思路,重新开始。这严重影响了他们的生产力和创造力”。
    Kaggle的Titanic数据集
    以下章节给出了数据准备的几种备选方案。我们将用非常著名的Titanic数据集(来自于Kaggle)来演示一些实用的例子。Titanic数据集被分为训练集和测试集,它将用于构建分析模型,这些模型用来预测哪个乘客可能会存活或死亡:
    这里写图片描述
    图3:Kaggle Titanic数据集的元数据
    这里写图片描述
    图4:Kaggle Titanic数据集的数据行示例
    原始数据集不能直接用于构建分析模型。它含有重复、缺失值以及包含各种不同信息的单元格。因此,在应用机器学习算法时,需要先将原始数据集处理好,以便获得最佳结果。以下是一些数据清洗和特征工程的例子:
    ● 通过特征提取(feature extraction)创建新列:获取每位乘客的姓名前缀,从而推断出其性别,例如,先生、夫人、小姐、大师
    ● 通过聚合创建新列,以查看每位乘客的旅行团中有多少人:“家庭大小= 1 + SibSp + Parch”
    ● 通过提取第一个字符来创建新列,以便排序和分析舱室:提取“舱室”列的第一个字符
    ● 删除数据集中的重复项,例如,乘客既在训练集中又在测试集中
    ● 通过填补将数据添加到空单元格,以便能够处理数据缺失的行,例如,年龄:将“不可用”替换为所有乘客的平均年龄或将其离散到对应的箱(bin)中;舱室:用“U”(未知)替换空值;或应用高级填补方法,例如,通过链式方程的多重填补(multiple imputation by chained equations)(MICE)
    ● 利用数据科学功能,例如,缩放、归一化、主成分分析(PCA)或Box-Cox,使所有数据处于“相似形状”,以便能够进行合理的分析
    以下章节阐述了各种编程语言、框架和数据准备工具。请注意,没有哪种方案适用于所有问题。此外,这些方案之间也有很多重叠(overlapping)。因此,根据用户角色和用例,许多问题可以使用不同的方案来解决。
    数据科学的数据预处理
    一些编程语言是专为数据科学项目而设计,或者是对它有非常好的支持,特别是R和Python。它们包含了机器学习算法的各种实现,诸如过滤或提取的预处理功能,以及诸如缩放、归一化或混洗(shuffle)的数据科学功能。数据科学家需要编写相对底层的代码来进行探索性数据分析与准备。与使用Java或C#的传统编程相反,使用R或Python进行数据预处理时,你不需要编写太多的代码;它更多地是让你了解统计概念以及算法的数据和经验,这些数据和经验可用于数据预处理和模型构建。
    这些编程语言是为数据科学家准备数据和构建分析模型而建立,它们并不适用于企业部署(将分析模型部署到具有高规模和高可靠性的新数据中)。因此,市场上提供了商业的enterprise runtime帮助你实现企业部署。通常,它们支持相同的源代码,因此你不需要为企业部署重写任何东西。对于R,你可以使用开源的Microsoft R Open(之前的Revolution R),或TIBCO Enterprise Runtime for R。后者具有不受GPL开源许可证限制的优势,因此你可以使用在任何嵌入式或外部环境里。
    下面的代码摘录于一个不错的R教程,它演示了如何使用基本的R语言来预处理和分析Titanic数据集:
    使用基本的R语言进行数据预处理: 存活是“是/否”
    =>类型转换:没有numeric值和对应的数据处理/分析
    data.combinedSurvived<as.factor(data.combinedSurvived)
    从全称里解析出姓和头衔
    data.combined[1:25, “Name”]
    name.splits <- str_split(data.combinedName,,)name.splits[1]last.names<sapply(name.splits,[,1)last.names[1:10]/+/+1temp.SibSp<c(trainSibSp, testSibSp)temp.Parch<c(trainParch, testParch)data.combinedFamilySize <- as.factor(temp.SibSp + temp.Parch + 1)
    除了对预处理的基本支持外,这些编程语言还提供了许多额外的数据科学软件包。例如,许多数据科学家利用R中非常强大的caret包来简化数据准备和减少代码量。该软件包简化了复杂回归和分类问题的模型准备与训练过程。它为数百个现有的R模型实现(在底层使用了各种各样的API)提供了一个通用接口。以下代码段使用了caret的通用API对Titanic数据集进行预处理:
    使用R caret包进行数据预处理:
    利用caret的preProcess函数对数据做归一化
    preproc.data.combined <- data.combined[, c(“ticket.party.size”, “avg.fare”)]
    preProc <- preProcess(preproc.data.combined, method = c(“center”, “scale”))
    你看到的是相对值而非绝对值(即彼此之间的关系):
    postproc.data.combined <- predict(preProc, preproc.data.combined)
    另一个用于数据预处理的R包是dplyr包。它不像caret包那样强大,并且只专注于操作、清洗和汇总(summarize)非结构化数据。 Dplyr旨在为数据操作的每个基本动作都提供一个函数:
    filter()(和slice())
    arrange()
    select()(和rename())
    distinct()
    mutate()(和transmute())
    summarise()
    sample_n (和sample_frac())
    因此,学习和理解许多数据操作任务变得容易。对于data.table包也是这样。

    数据科学家或开发者的大数据集预处理

    正如你所见的,在R语言里你有许多方法来预处理数据集。
    诸如R或Python这样的编程语言可用于处理小数据集。但是,它们并不是为处理真正的大数据集而创建;与此同时,我们经常需要分析几个GB、TB甚至PB级别的数据。类似于Apache Hadoop或Apache Spark的大数据框架则是为处于边缘的(即数据所在位置)弹性扩展(elastic scalability)和数据预处理而创建。
    这些大数据框架侧重于“底层”编码,并且配置起来比R或Python环境要复杂得多。商业软件,如Hortonworks、Cloudera、MapR或Databricks可以帮助解决此问题。通常,数据科学家与开发人员相互合作来完成大数据项目。后者负责集群配置、部署和监控,而数据科学家则利用R或Python API编写用于数据预处理和构建分析模型的代码。
    源代码通常看起来与仅使用R或Python的代码非常相似,但数据预处理是在整个集群上并行完成的。下面的示例演示了如何使用Spark的Scala API对Titanic数据集进行预处理和特征工程:
    使用Scala和Apache Spark API进行数据预处理:
    特征工程:创建家庭大小特征
    (兄弟姐妹/配偶+父母/孩子+1)
    val familySize: ((Int, Int) => Int) = (sibSp: Int, parCh: Int) => sibSp + parCh + 1
    val familySizeUDF = udf(familySize)
    val dfWithFamilySize = df.withColumn(“FamilySize”, familySizeUDF(col(“SibSp”), col(“Parch”)))
    // 为年龄列填充空值
    val avgAge = trainDF.select(“Age”).union(testDF.select(“Age”))
    .agg(avg(“Age”))
    .collect() match {
    case Array(Row(avg: Double)) => avg
    case _ => 0
    }
    当然,你可以使用Spark的Java或Python API做同样的事情。

    平民数据科学家的数据预处理

    通常,你想要敏捷并且快速得到结果。这常常需要在准备和分析数据集时大量地试错。你可以利用现存的各种快捷易用的数据科学工具。这些工具提供了:
    ● 开发环境和运行/执行服务器
    ● 使用拖放与代码生成的可视化“编码”
    ● 集成各种数据科学框架,如R、Python或更强大的(诸如Apache Hadoop、Apache Spark或底层的H2O.ai)大数据框架
    数据科学家可以使用这些工具来加速数据预处理和模型建立。此外,该类工具还帮助解决了数据预处理和机器学习算法的实现,因此没有太多项目经验的平民数据科学家也可以使用它们。一些工具甚至能够提出建议,这些建议有助于用户预处理、显示和分析数据集。这些工具在底层人工智能的驱动下变得越来越智能。
    下面的例子展示了如何使用两个开源数据科学工具KNIME和RapidMiner来预处理Titanic数据集:
    这里写图片描述
    图:使用KNIME来预处理Titanic数据集
    这里写图片描述
    图:使用RapidMiner来预处理Titanic数据集
    你可以使用可视化IDE来配置预处理,而非如前所述的用R或Scala编写源代码。对大多数用户来说,这使得数据准备和分析变得更容易,并且数据的维护和移交也变得更容易。

    业务分析师或平民数据科学家的数据整理

    数据整理(有时也称为data munging)是一种使用图形工具的数据准备方法,该方法简单直观。这些工具侧重于易用性和敏捷的数据准备。因此,它不一定由开发人员或数据科学家完成,而是所有的用户都可以(包括业务分析师或平民数据科学家)。DataWrangler和Trifacta Wrangler是数据整理的两个示例。
    这里写图片描述
    图:用于数据整理的Trifacta
    请注意,这些工具没有数据预处理框架那么强大,因此它们经常用于数据准备的最后一公里。它们不会替换其它的集成选项,如ETL(提取-变换-加载)工具,或使用R、Python、KNIME、RapidMiner等进行的数据预处理。
    如引言中所讨论,因为数据整理与实际数据分析相互解耦,所以数据整理自身的工具可能会存在一些不足之处。可视化分析工具中的数据整理允许在数据的探索性分析期间进行inline数据整理。单个的用户使用单一的工具就能够完成它。例如,请参阅TIBCO Spotfire示例,它结合了可视化分析与inline数据整理(以及其它的数据科学功能来构建分析模型):
    这里写图片描述
    图:可视化分析工具TIBCO Spotfire中的inline数据整理
    数据整理工具和带有inline数据整理的可视化分析工具可以被每种用户角色使用:业务分析师、(平民)数据科学家或开发人员,这些工具能够加速数据准备和数据分析。
    本文重点介绍了用于建立机器学习模型的数据准备。你可以使用编程语言(如R或Python)、数据科学工具(如KNIME或RapidMiner)、数据整理(使用DataWrangler或Trificata)或inline数据整理(通过TIBCO Spotfire)。通常,在开始这一切之前,你需要能够访问你拥有的所有数据,这些数据存储于各种或多或少整理过的数据源中(如关系数据库、数据仓库、大数据集群)。因此,在以下两部分,我们将简要介绍用于数据获取(data ingestion)的ETL和流式分析工具,通常数据获取还包括数据准备的某些部分,特别是数据聚合和数据清洗。

    开发者的ETL(提取-变换-加载)和DQ(数据质量,Data Quality)

    ETL工具是为开发者集成各种数据源而设计的,它包括了许多遗留和专有(proprietary)接口(如Mainframe或EDIFACT接口),这些接口具有十分复杂的数据结构。它还包括了数据清洗(在上下文中通常被称为“数据质量”工具),并将重点放在易用性和使用可视化编码的企业部署上(类似于如KNIME或RapidMiner的数据科学工具,但是专注于ETL和数据质量)。它们还支持大数据框架,如Apache Hadoop和Apache Spark。此外,它们还为质量改进提供了开箱即用(out-of-the-box )的支持,例如,地址验证。ETL和DQ通常在长时间运行的批处理进程中实现,因此如果你需要使用实时数据构建模型,那么这有时可能会产生负面影响。
    ETL和DQ工具的例子是一些开源工具,如Pentaho或Talend,或专有供应商Informatica。市场正在向更简单易用的Web用户界面转移,这些简单易用的界面能够让其他用户角色也执行一些基本的任务。

    开发者的数据获取与流式分析

    数据获取与流式分析工具可用于在流(stream)中添加和预处理数据。这些框架允许批量地或实时地预处理数据。下图展示了一个典型的流式分析流程,它包括数据获取、预处理、分析、处理和输出:
    这里写图片描述
    图:流式分析流程的步骤
    目前市场上有各种各样的框架和工具。它们都以这种或那种方式支持类似Hadoop或Spark的大数据框架。举几个例子:
    ● 数据获取开源框架(仅关注数据获取和预处理步骤):Apache NiFi、StreamSets、Cask Hydrator
    ● 流式处理开源框架(完整的流式分析流程):Apache Storm、Apache Flink、Apache Apex
    ● 流式处理商业软件(完整的流式分析流程):Software AG Apama、IBM Streams、TIBCO StreamBase
    使用这些工具(包括ETL)的巨大优势是,你可以使用同一套工具或框架(对历史数据)进行数据预处理,以及(对新数据)进行实时处理(以便在变化的数据里使用分析模型)。这将会是一个不错的选择,用户不仅可以保持小而精的工具集,而且还能通过一套工具同时获得ETL/获取和实时处理。下图是一个使用TIBCO StreamBase对Titanic数据集进行预处理的例子:
    这里写图片描述
    图:Titanic数据集的流式预处理
    对于数据获取和ETL工具,流式分析的市场正在转向更简单的Web用户界面,这些简单的用户界面让其他用户角色也能执行一些基本的任务。但这不会取代现有的工具在更高级别用例里的使用,而是为分析师或数据科学家提供了新的选择。在没有开发人员的帮助下,他们能够更容易和更直接地部署一些规则、关联或分析模型。

    数据准备是机器学习项目成功的关键

    使用机器学习或深度学习技术构建分析模型并不容易。数据准备占去整个分析管道的60%到80%。市场上有各种用于数据清洗和特征工程的编程语言、框架和工具。它们之间的功能有重叠,也各有权衡。
    数据整理是数据预处理的重要扩展(add-on)。它最适合在可视化分析工具中使用,这能够避免分析流程被打断。可视化分析工具与开源数据科学组件(component)之间,如R、Python、KNIME、RapidMiner互为补充。
    避免过多地使用组件能够加速数据科学项目。因此,在数据准备步骤中利用流式获取框架或流式分析产品会是一个不错的选择。我们只需要编写一次预处理的步骤,然后将其用于历史数据的批处理中,从而进行分析模型的构建,同时,还可以将其用于实时处理,这样就能将我们构建的分析模型用到新的事件中。
    作者介绍
    Kai Wähner,TIBCO软件的技术传播者和社区管理者,TIBCO软件是市场上领先的集成和分析中间件提供商。他主要的专业领域包括大数据、高级分析、机器学习、集成、SOA、微服务、BPM、云、物联网和编程语言(如Java EE、Groovy或Golang)。他经常在其博客网站上撰写关于新技术的博客、文章和会议演讲。

    展开全文
  • 几种常见的排序方法整理 一、直接插入排序 插入排序是一种简单直观的排序算法。通过构建有序序列,对于未排序数据,在已排序序列中从后向前扫描,找到相应位置并插入。插入排序在从后向前扫描的过程中,需要反复把已...

    几种常见的排序方法整理

    一、直接插入排序

    插入排序是一种简单直观的排序算法。通过构建有序序列,对于未排序数据,在已排序序列中从后向前扫描,找到相应位置并插入。插入排序在从后向前扫描的过程中,需要反复把已排序元素逐步向后挪位,为最新元素提供插入空间。

    算法:
    将需要排序的数列看成一个数组,i初始化指向数组1号下标,j初始化指向数组0号下标,和i对应数值进行比较,比较一次往后退一步,如果j对应数值大于i对应数值,数值进行交换,直到i前面的数字都比它小,i往后走。

    时间复杂度:(1)最坏情况是O(n^2)
    (2) 最好情况是有序情况:O(n)
    空间复杂度:O(1)
    稳定性:稳定

    代码:

    public static void insertSort(int[] array){
        int tmp = 0;
        int j ;
        for(int i=1; i<array.length; i++){
             tmp = array[i];
            for( j=i-1; j>=0; j--){
                if(array[j] > tmp){
                    array[j+1] = array[j]; //调换位置
                }else{
                   // array[j+1] = tmp;   //不用换,放回原位
                    break;
                }
            }
            array[j+1] = tmp;   //不用换,放回原位
        }
    }
    

    二、希尔排序

    希尔排序也是插入排序的一种,它是采用分组的思想,对每组进行插入排序。

    代码:

    public static void shellSort(int[] array){
        int[] drr = {5,3,1};
        for(int i = 0; i<drr.length; i++){
            shell(array,drr[i]);
        }
    }
    public static void shell(int[] array,int gap){
       int tmp = 0;
       for(int i = gap; i<array.length; i++){
           tmp = array[i];
           int j;
           for(j=i-gap; j>=0; j-=gap){
               if(array[j]>tmp){
                   array[j+gap] = array[j];
               }else {
                   break;
               }
           }
           array[j+gap]=tmp;
       }
    
    }
    

    三、选择排序

    算法思想:
    先从数组第一个数字开始,把这个数字和这个数字之后的所有数字进行比较,如果比这个数字小就交换,然后把数组第二个数字和它之后的所有数字进行比较,比他小就交换,以此类推,直到数组最后一个数字。

    代码:

     public static void selectSort(int[] array){
        for(int i=0; i<array.length; i++){
            for(int j=i+1; j<array.length; j++){
                if(array[j]<array[i]){
                    int tmp = array[i];
                    array[i] = array[j];
                    array[j] = tmp;
                }
            }
    
            }
    
    }
    

    时间复杂度:O(n^2)
    空间复杂度:O(1)
    稳定性:不稳定

    四、堆排序

    首先将数组建立成一个大根堆,从数组最后一个数字开始,和数组0号下标数字进行交换,然后采用向下调整法。接着将倒数第二个数字和数组0号下标数字进行交换,然后采用向下调整法,以此类推,直到0号下标数字。

    代码:

    public static void heapSort(int[] array){
        creatHeap(array);
        int end = array.length-1;
        while(end>0){
            int tmp = array[end];
            array[end] = array[0];
            array[0] = tmp;
            adjustDown(array,0,end);
            end--;
        }
    }
     //建立大根堆
    public static void creatHeap(int[] array){
        for(int i = (array.length-1-1)/2; i>=0; i--){
            adjustDown(array,i,array.length);
        }
    }
    //向下调整法
    public static void adjustDown(int[] array,int root,int len){
        int patrnt = root;
        int child = root*2+1;
        //最起码有左孩子
        while(child<len){
            //有右孩子且左孩子小于右孩子,进行交换
            if(child+1<len && array[child]<array[child+1]){
             int tmp = array[child];
             array[child] = array[child+1];
             array[child+1] = tmp;
            }
            //如果左孩子大于父亲结点,要进行交换
            if (array[child] > array[patrnt]) {
                int tmp = array[child];
                array[child] = array[patrnt];
                array[patrnt] = tmp;
                patrnt = child;
                child = patrnt*2+1;
            }else{
                break;
            }
        }
    }
    

    时间复杂度:O(nlogn)
    空间复杂度:O(1)
    稳定性:不稳定

    五、冒泡排序

    冒泡排序是每一趟都从第一个数字开始,将数组每一个数字和它后一个数字进行比较,比它小就交换。如此往复,直到序列有序。

    代码:

    public static void bubleSort(int[] array){
        //i表示趟数
        for(int i=0; i<array.length-1; i++){
            for(int j=0; j<array.length-1-i; j++){
                if(array[j]>array[j+1]){
                    int tmp = array[j];
                    array[j] = array[j+1];
                    array[j+1] = tmp;
                }
            }
        }
    }
    

    时间复杂度:O(n^2)
    空间复杂度:O(1)
    稳定性:不稳定

    六、快速排序

    快速排序,又称划分交换排序。通过一趟排序将要排序的数据分割成两部分,然后再按此方法对两部分数据分别进行快速排序,以此达到整个数据变成有序序列
    步骤为:
    (1) 从数列找出一个元素,称为“基准”。
    (2) 重新排序数列,所有元素比基准值小的摆放在基准前面,所有元素比基准值大的摆在基准的后面。在这个分区结束之后,该基准就处于数列的中间位置。这个称为分区操作。
    (3)把基准元素左边的数值序列用递归的方法进行快速排序,右边序列也如此。直到整个序列有序。

    代码:

    public static void quickSort(int[] array){
    
        quick(array,0,array.length-1);
    }
    public static void quick(int[] array,int left,int right){
        if(left>=right){
            return;
        }
       int par = partition(array,left,right);
        //递归排序左边和右边
        quick(array,left,par-1);
        quick(array,par+1,right);
    
    }
    //找基准
    public static int partition(int[] array,int left,int right){
        int tmp = array[left];
        while(left<right){
    
            while(left<right && array[right]>=tmp){
                right--;
            }
            array[left]=array[right];
            while(left<right && array[left]<=tmp) {
                left++;
            }
            array[right] = array[left];
        }
        array[left] = tmp;
        return left;
    }
    

    时间复杂度:O(nlogn)
    最坏情况:1 2 3 4 5 6 7 8 9 / 9 8 7 6 5 4 3 2 1 :O(n^2)
    空间复杂度:O(logn)~O(n)
    稳定性:不稳定

    七、归并排序

    归并排序是采用分治法,思想就是先将数组分解为一个一个的数(将数组从中间一分为二,然后递归分解左边和右边),再合并数组。
    合并的基本思路是比较两个数组的最前面的数,谁小就先取谁,取了后相应的指向就往后移一位。然后比较,直至一个数组为空,最后把另一个数组的剩余部分复制过来即可。

    代码:

    public static void mergeSort(int[] array){
    
        mergeSortIn(array,0,array.length-1);
    }
    //分解
    public static void mergeSortIn(int[] array,int low,int high){
        if(low>=high){
            return;
        }
        //分解(从数组中间一分为二,直至分解为一个一个的数)
        int mid = (low+high)>>>1; //右移相当于除2
        mergeSortIn(array,low,mid);
        mergeSortIn(array,mid+1,high);
        //归并(将一个一个的数按序归并)
        merge(array,low,mid,high);
    }
     //归并
    public static void merge(int[] array,int low,int mid,int high){
        int s1 = low;
        int s2 = mid+1;
        int len = high-low+1; //新数组的长度
        int[] ret = new int[len]; //新建一个数组用来存放归并排序后的数
        int i = 0; //表示ret数组的下标
    
        while (s1<=mid && s2<=high){
            if(array[s1] <= array[s2]){
                ret[i++] = array[s1++];
            }else {
                ret[i++] = array[s2++];
            }
        }
        while (s1<=mid){
            ret[i++] = array[s1++];
        }
        while (s2<=high){
            ret[i++] = array[s2++];
        }
        for(int j= 0; j<ret.length; j++){
            array[j+low] = ret[j];
        }
    }
    

    时间复杂度:nlogn
    空间复杂度:O(n)
    稳定性:稳定

    展开全文
  • 出现该问题的原因可能是之前转移的时候将网站文件上传到主机空间后,进行过一次网站安装,导致新建了一次数据库,创建了新的数据表,导致重新导入数据库时数据表重复。解决方法就是将查找到提示的这个已存在的XXX ...
  • 常见数据分析方法

    2020-10-20 22:38:28
    描述统计是通过图表或数学方法,对数据资料进行整理、分析,并对数据的分布状态、数字特征和随机变量之间关系进行估计和描述的方法。描述统计分为集中趋势分析、离中趋势分析和相关分析三大部分。 1. 集中趋势分析 ...
  • jsonview插件的常见使用方法整理

    千次阅读 2017-05-22 16:52:00
    Jsonview是目前最热门一款开发者工具插件,确切来说jQuery JSONView是一款非常实用格式化和语法高亮JSON格式数据查看器jQuery...常用使用方法有: 1.在页面中引入jquery和jquery.jsonview.js,以及jquery....
  • 所谓封装,也就是把客观事物封装成抽象的类,并且类可以把自己的数据方法只让可信的类或者对象操作,对不可信的进行信息隐藏。封装是面向对象的特征之一,是对象和类概念的主要特性。 (推荐学习:java常见面试题)...
  • 1. OLEDB 这种方式将Excel作为一个数据源,直接用Sql语句...2) 列类型的判断逻辑不合理,当指定了首行作为头(header)的时候,Oledb会根据该列的前若干行数据类型类判断该列的数据类型,这会导致数据丢失。例如某...
  • 10月4号接了一个需求:写个脚本下载几个网站的数据,以减轻其日常手工下载数据之苦,毕竟需要下载近300个文件,手工点选下载确实苦不堪言。 紧锣密鼓写了3天,期间也遇到了不少问题,最终都一一解决,作为总结,我将...
  • 作为数据分析初学者,我感受最深就是很多时候我想分析处理下数据,无从下手,有代码也不记得,查找使用方法又得花费时间,所以我整理了一份数据分析问答形式专题,这里都是平时实战中常用到...
  • 关于使用sql删除数据库重复的数据方法整理:1.数据完全重复通过一个临时表过渡一下insert into table1 select distinct field from tabledrop table tableinsert into table select * from table12.某个字段重复这...
  • java中有几种常用的数据结构,主要分为Collection和map两个主要接口(接口只提供方法,并不提供实现),而程序中最终使用的数据结构是继承自这些接口的数据结构类。其主要的关系(继承关系)有: Collection—-&...
  • 我们在准备实施某个项目之前肯定会去...对于用户行为的数据整理是比较重要的,我们一般采用哪些收集数据的方法呢?在这篇文章中,老蒋整理几个比较常用的用户行为收集数据的方法,便于我们日后在产品运营过程中起到...
  • 并且在学习和实践过程中,整理了很多相关内容:常用代码,常见错误,常用方法,常用数据结构,常用代码段,常用库,经典思想等众多内容,并且会随着本人不断学习过程中持续进行更新,请保持关注 思维导图源文件...
  • sql语句优化是最直接影响数据交互效率方式,这里详细总结用过及接触过sql语句优化方法! 1、应尽量避免在 where 子句中使用!=或&lt;&gt;操作符,否则将引擎放弃使用索引而进行全表扫描。 2、对查询...
  • 对几种排序方法进行简单描述和放上代码 希尔排序 把一个待排序数组划分为几个部分,每次拿第i+1部分第j位数字和第i部分第j位数字进行比较,如果前者比较小就互换位置,否则不用。 // 希尔排序 void ...
  • 原文地址: 雷锋网按:本文为雷锋字幕组编译的技术博客,原标题Data Augmentation | How to use Deep Learning when you have Limited Data—Part 2,作者Ralph Fehrer。...这是《在有限的数据下如何使用深度学习...
  • 本篇文章中,笔者把之前自己码代码过程中出现一些已解决的常见bug和解决方法进行了整理,还在不断更新中~~~主要内容有:一、与读取CSV文件有关报错1.1 'utf-8' codec can't decode1.2 pandas.read_csv() 报错...
  • 所谓封装,也就是把客观事物封装成抽象的类,并且类可以把自己的数据方法只让可信的类或者对象操作,对不可信的进行信息隐藏。封装是面向对象的特征之一,是对象和类概念的主要特性。 (推荐学习:java常见面试题)...
  • 【10年运维整理】服务器常见故障及其解决方法

    万次阅读 多人点赞 2018-05-22 16:44:55
    近日小编将针对一些常见的服务器故障现象和解决方法跟管理者分享一下,以便更好的更快的进行故障处理和排查。01服务器常见故障及现象 有关服务器无法启动的主要原因 : ①市电或电源线故障(断电或接触...
  • 作为数据分析初学者,我感受最深就是很多时候我想分析处理下数据,无从下手,有代码也不记得,查找使用方法又得花费时间,所以我整理了一份数据分析问答形式专题,这里都是平时实战中常用到,方便以后直接...
  • 本篇文章中,笔者把之前自己码代码过程中出现一些已解决的常见bug和解决方法进行了整理,还在不断更新中~~~主要内容有:一、与读取CSV文件有关报错1.1 'utf-8' codec can't decode1.2 pandas.read_csv() 报错...
  • Excel表格的使用过程中会遇到很多问题,对新手来说可能就比较麻烦,不知道如何解决,今天给大家分享6个常见的问题和解决方法,你一定遇到过这样的问题。1、数字0不见了单元格开头输入的数字0为什么不显示出来?解决...
  • 常见面试题整理

    2020-07-08 21:54:01
    一些自己觉得比较常见的面试题做整理,以备不时之需 BFC是什么?如何创建?使用场景? js的执行机制是怎么样的? 深拷贝和浅拷贝? 原型和原型链? 对构造函数的理解? 函数的防抖节流? 什么是闭包,什么是递归? ...
  • 不管是为了面试还是自身编程能力的提升,花时间去研究常见的算法还是很有必要的。下面是自己对于算法这部分的学习总结。算法是指解题方案的准确而完整的描述,是一系列解决问题的清晰指令,算法代表着用系统的方法...
  • * 选择排序:每次循环将当前的数据与其它数据一一进行比较, * 如果出现比当前数据小的则交换位置 */ int[] arr = {3,2,1,9,5}; //外层循环:确定参与比较的数据 //(最后一位数...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 1,073
精华内容 429
关键字:

常见的数据整理方法