2019年2月 – gitweixin

Android 2月 22,2019

测试admob是否能正常显示广告

尤其是在中国，由于广告投放等的问题，admob广告不一定正常显示，这时可以请求测试广告。
AdRequest adRequest = new AdRequest();
adRequest.addTestDevice(AdRequest.TEST_EMULATOR); // 模拟器
adRequest.addTestDevice(“TEST_DEVICE_ID”); // 测试 Android 设备
您可以在对设备进行调试时请求广告，然后在 logcat 输出中找到设备 ID。也可以用下面的代码来获取设备ID。

String android_id = Settings.Secure.getString(this.getContentResolver(), Settings.Secure.ANDROID_ID);
String deviceId = DeviceUtil.md5(android_id).toUpperCase();

public static final String md5(final String s) {
    try {
        // Create MD5 Hash
        MessageDigest digest = java.security.MessageDigest
                .getInstance("MD5");
        digest.update(s.getBytes());
        byte messageDigest[] = digest.digest();

        // Create Hex String
        StringBuffer hexString = new StringBuffer();
        for (int i = 0; i < messageDigest.length; i++) {
            String h = Integer.toHexString(0xFF & messageDigest[i]);
            while (h.length() < 2)
                h = "0" + h;
            hexString.append(h);
        }
        return hexString.toString();

    } catch (NoSuchAlgorithmException e) {
     //   Logger.logStackTrace(TAG,e);
        e.printStackTrace();
    }
    return "";
}

作者 east

Spark 2月 13,2019

Spark本地向量(Local vector)详细解析

一个本地向量拥有从0开始的integer类型的索引以及double类型的值，它保存在单台机器上面。MLlib支持两种类型的本地向量：稠密(dense)向量和稀疏(sparse)向量。一个稠密向量通过一个double类型的数组保存数据，这个数组表示向量的条目值(entry values)；一个稀疏向量通过两个并行的数组（indices和values）保存数据。例如：

向量（5.2，0.0，5.5）

密集向量表示：[5.2，0.0，5.5]

稀疏向量表示：（3，[0,2]，[5.2,5.5]） # 3是向量（5.2，0.0，5.5）的长度，除去0值外，其他两个值的索引和值分别构成了数组[0,2]和数组[5.2,5.5]。

Vector是所有局部向量的基类，Dense-Vector和SparseVector都是Vector的具体实现。

本地向量的基类是Vector，Spark提供了两种实现： DenseVector和SparseVector。 Spark官方推荐使用Vectors中实现的工厂方法去创建本地向量。下面是创建本地向量的例子。

 
 
import org.apache.spark.mllib.linalg.{Vector, Vectors} 
// 创建一个dense vector (5.2, 0.0, 5.5).
 val dv: Vector = Vectors.dense(5.2, 0.0, 5.5) 
// 创建一个sparse vector (5.2, 0.0, 5.5)并且指定它的索引和值
 val sv1: Vector = Vectors.sparse(3, Array(0, 2), Array(5.2, 5.5)) 
// 创建一个sparse vector (5.2, 0.0, 5.5)并且指定它的索引和值，通过指定非0的值，位置0是5.2，位置2是5.5 
val sv2: Vector = Vectors.sparse(3, Seq((0, 5.2), (2, 5.5)))

注意，Scala默认引入scala.collection.immutable.Vector，这里我们需要主动引入MLLib中的org.apache.spark.mllib.linalg.Vector来操作。我们可以看看Vectors对象的部分方法。

作者 east

Hadoop 2月 12,2019

yarn权限问题

① YARN 执行作业遇到 Unauthorized request to start container 问题：

datanode 与 namenode 之间未设置时间同步，所以引起该异常。解决方案：多个 datanode 与 namenode 进行时间同步。

②HDFS 客户端的权限错误：Permission denied

1、在系统的环境变量或 Java JVM 变量里面添加HADOOP_USER_NAME，这个值具体等于多少看自己的情况，以后会运行 Hadoop 上的 Linux 的用户名。（修改完重启 eclipse，不然可能不生效）

2、将当前系统的帐号修改为 hadoop

3、使用 HDFS 的命令行接口修改相应目录的权限，hadoop fs -chmod 777 /user,后面的/user 是要上传文件的路径，不同的情况可能不一样，比如要上传的文件路径为hdfs://namenode/user/xxx.doc，则这样的修改可以，如果要上传的文件路径为hdfs://namenode/Java/xxx.doc，则要修改的为 hadoop fs -chmod 777 /java 或者 hadoop fs – chmod 777 /，java 的那个需要先在 HDFS 里面建立 Java 目录，后面的这个是为根目录调整权限。

推荐第一种

作者 east

Hadoop 2月 12,2019

hadoop环境变量问题

bash:haoop:command not found

今天配置完 Hadoop 运行 hadoop 命令 hadoop fs -ls 时出现：

bash:haoop:command not found

后来经过检查，原来是配置文件中 HADOOP_HOME 变量引用前少了个$，修改完毕后可以正常运行了。

vi /etc/profile

export JAVA_HOME=/usr/Java/jdk1.7.0_75 export HADOOP_HOME=/opt/hadoop-2.6.0

export PATH=.:$HADOOP_HOME/bin:$JAVA_HOME/bin:$PATH

修改完后运行 source /etc/profile 让其立即生效！

在 start-all.sh 是出现异常：

Error:Cannot find configuration directory:/etc/hadoop

解决办法：

在 hadoop-env.sh 配置文件中将

export HADOOP_CONF_DIR=${HADOOP_CONF_DIR:-“etc/hadoop”}

替换成

export HADOOP_CONF_DIR=/usr/hadoop-2.6.0/etc/hadoop

修改完后运行 source hadoop-env.sh 让其立即生效！

作者 east

Hadoop 2月 12,2019

namenode常见问题

1、cannot delete name node is in safe mode

问题：向 hdfs put 数据的时候，导致了 name node is in safe mode，然后使

用 Hadoop dfsadmin -safemode leave 后，解除了安全模式。可是再次使用 hdfs put 或 rm

数据，仍旧导致 name node 进入安全模式。

答案：分析了一下，问题是 namenode 所在机器的硬盘满了。因此即使使用了 hadoop dfsadmin -safemode leave 之后，仍旧不能使用 hdfs。

解决办法：

1，删除 namenode 所在机器的一些数据（本地数据） 2，结束安全模式 hadoop dfsadmin -safemode leave 3，可以正常使用 hdfs 了

2、Hadoop namenode 无法启动

最近遇到了一个问题，执行 start-all.sh 的时候发现 JPS 一下 namenode 没有启动。每次开机都得重新格式化一下 namenode 才可以

其实问题就出在tmp 文件，默认的 tmp 文件每次重新开机会被清空，与此同时 namenode

的格式化信息就会丢失

于是我们得重新配置一个 tmp 文件目录

首先在 home 目录下建立一个 hadoop_tmp 目录

sudo mkdir ~/hadoop_tmp

然后修改 Hadoop/conf 目录里面的 core-site.xml 文件，加入以下节点：

<name>hadoop.tmp.dir</name>

<value>/home/chjzh/hadoop_tmp</value>

<description>A base for other temporary directories.</description>

</property>

注意：我的用户是 chjzh 所以目录是/home/chjzh/hadoop_tmp OK 了，重新格式化Namenode

hadoop namenode –format

然后启动 hadoop

start-all.sh

执行下 JPS 命令就可以看到 NameNode 了

作者 east

Spark 2月 12,2019

Spark ML机器学习：元素智能乘积-ElementwiseProduct

ElementwiseProduct对每一个输入向量乘以一个给定的“权重”向量。换句话说，就是通过一个乘子对数据集的每一列进行缩放。这个转换可以表示为如下的形式：

实例：

import org.apache.spark.sql.SparkSession

object ElementwiseProductExample {
  def main(args: Array[String]): Unit = {
    val sparkConf = new SparkConf();
    sparkConf.setMaster("local[*]").setAppName(this.getClass.getSimpleName)
    val spark = SparkSession
      .builder
      .config(sparkConf)
      .appName("ElementwiseProductExample")
      .getOrCreate()

    // $example on$
    // Create some vector data; also works for sparse vectors
    val dataFrame = spark.createDataFrame(Seq(
      ("a", Vectors.dense(1.0, 2.0, 3.0)),
      ("b", Vectors.dense(4.0, 5.0, 6.0)))).toDF("id", "vector")

    val transformingVector = Vectors.dense(0.0, 1.0, 2.0)
    val transformer = new ElementwiseProduct()
      .setScalingVec(transformingVector)
      .setInputCol("vector")
      .setOutputCol("transformedVector")

    // Batch transform the vectors to create new column:
    transformer.transform(dataFrame).show()
    // $example off$

    spark.stop()
  }
}

输出结果:

+—+————-+—————–+
| id| vector|transformedVector|
+—+————-+—————–+
| a|[1.0,2.0,3.0]| [0.0,2.0,6.0]|
| b|[4.0,5.0,6.0]| [0.0,5.0,12.0]|
+—+————-+—————–+

作者 east

Spark 2月 11,2019

Spark ML机器学习：SQLTransformer

我们都很喜欢sql语句，简单好用又熟悉，那么Spark ML很人性化的为我们提供了SQLTransformer类，使得我们能用我们熟悉的SQL来做特征转化。它支持SparkSql中的所有select选择语句,sum(),count(),group by,order by等等都可以用！形如”SELECT …FROM __THIS__”。’__THIS__’代表输入数据的基础表。

SQLTransformer实现了一种转换,这个转换通过SQl语句来定义。目前我们仅仅支持的SQL语法是像SELECT ... FROM __THIS__ ...的形式。这里__THIS__表示输入数据集相关的表。例如,SQLTransformer支持的语句如下:

SELECT a, a + b AS a_b FROM __THIS__
SELECT a, SQRT(b) AS b_sqrt FROM __THIS__ where a > 5
SELECT a, b, SUM(c) AS c_sum FROM __THIS__ GROUP BY a, b

例子

假设我们拥有下面的DataFrame,它的列名是id,v1,v2。

id  |  v1 |  v2
----|-----|-----
 0  | 1.0 | 3.0
 2  | 2.0 | 5.0

下面是语句SELECT *, (v1 + v2) AS v3, (v1 * v2) AS v4 FROM __THIS__的输出结果。

 id |  v1 |  v2 |  v3 |  v4
----|-----|-----|-----|-----
 0  | 1.0 | 3.0 | 4.0 | 3.0
 2  | 2.0 | 5.0 | 7.0 |10.0

下面是程序调用的例子。

// $example on$
import org.apache.spark.SparkConf
import org.apache.spark.ml.feature.SQLTransformer
// $example off$
import org.apache.spark.sql.SparkSession

object SQLTransformerExample {
  def main(args: Array[String]) {
    val sparkConf = new SparkConf();
    sparkConf.setMaster("local[*]").setAppName(this.getClass.getSimpleName)
    val spark = SparkSession
      .builder
        .config(sparkConf)
      .appName("SQLTransformerExample")
      .getOrCreate()

    // $example on$
    val df = spark.createDataFrame(
      Seq((0, 1.0, 3.0), (2, 2.0, 5.0))).toDF("id", "v1", "v2")

    val sqlTrans = new SQLTransformer().setStatement(
      "SELECT *, (v1 + v2) AS v3, (v1 * v2) AS v4 FROM __THIS__")

    sqlTrans.transform(df).show()
    // $example off$

    spark.stop()
  }
}

输出结果：

+—+—+—+—+—-+
| id| v1| v2| v3| v4|
+—+—+—+—+—-+
| 0|1.0|3.0|4.0| 3.0|
| 2|2.0|5.0|7.0|10.0|
+—+—+—+—+—-+

作者 east

Spark 2月 11,2019

Spark ML机器学习：Tokenizer分词器

当我们的输入数据为文本（句子）的时候，我们会想把他们切分为单词再进行数据处理，这时候就要用到Tokenizer类了。 Tokenization是一个将文本(如一个句子)转换为个体单元(如词)的处理过程。一个简单的Tokenizer类就提供了这个功能。下面的例子展示了如何将句子转换为此序列。

RegexTokenizer基于正则表达式匹配提供了更高级的断词(tokenization)。默认情况下,参数pattern(默认是\s+)作为分隔符, 用来切分输入文本。用户可以设置gaps参数为false用来表明正则参数pattern表示tokens而不是splitting gaps,这个类可以找到所有匹配的事件并作为结果返回。下面是调用的例子。

import org.apache.spark.SparkConf
import org.apache.spark.ml.feature.{RegexTokenizer, Tokenizer}
import org.apache.spark.sql.SparkSession
import org.apache.spark.sql.functions._
// $example off$

object TokenizerExample {
  def main(args: Array[String]): Unit = {
    val sparkConf = new SparkConf();
    sparkConf.setMaster("local[*]").setAppName(this.getClass.getSimpleName)
    val spark = SparkSession
      .builder
      .config(sparkConf)
      .appName("TokenizerExample")
      .getOrCreate()

    // $example on$
    val sentenceDataFrame = spark.createDataFrame(Seq(
      (0, "Hi I heard about Spark"),
      (1, "I wish Java could use case classes"),
      (2, "Logistic,regression,models,are,neat")
    )).toDF("id", "sentence")

    val tokenizer = new Tokenizer().setInputCol("sentence").setOutputCol("words")
    val regexTokenizer = new RegexTokenizer()
      .setInputCol("sentence")
      .setOutputCol("words")
      .setPattern("\\W") // alternatively .setPattern("\\w+").setGaps(false)

    val countTokens = udf { (words: Seq[String]) => words.length }

    val tokenized = tokenizer.transform(sentenceDataFrame)
    tokenized.select("sentence", "words")
        .withColumn("tokens", countTokens(col("words"))).show(false)

    val regexTokenized = regexTokenizer.transform(sentenceDataFrame)
    regexTokenized.select("sentence", "words")
        .withColumn("tokens", countTokens(col("words"))).show(false)
    // $example off$

    spark.stop()
  }
}

输出结果:

作者 east

Spark 2月 11,2019

Spark ML机器学习：多项式转化-PolynomialExpansion

Polynomial expansion是一个将特征展开到多元空间的处理过程，
运用于特征值进行一些多项式的转化，比如平方啊，三次方。它通过n-degree结合原始的维度来定义。比如设置degree为2就可以将(x, y)转化为(x, x x, y, x y, y y)。PolynomialExpansion提供了这个功能。下面的例子展示了如何将特征展开为一个3-degree多项式空间。


// $example on$
import org.apache.spark.SparkConf
import org.apache.spark.ml.feature.PolynomialExpansion
import org.apache.spark.ml.linalg.Vectors
// $example off$
import org.apache.spark.sql.SparkSession

object PolynomialExpansionExample {
  def main(args: Array[String]): Unit = {
    val sparkConf = new SparkConf();
    sparkConf.setMaster("local[*]").setAppName(this.getClass.getSimpleName)
    val spark = SparkSession
      .builder
      .config(sparkConf)
      .appName("PolynomialExpansionExample")
      .getOrCreate()

    // $example on$
    val data = Array(
      Vectors.dense(2.0, 1.0),
      Vectors.dense(0.0, 0.0),
      Vectors.dense(3.0, -1.0)
    )
    val df = spark.createDataFrame(data.map(Tuple1.apply)).toDF("features")
    //setDegree表示多项式最高次幂 比如1.0,5.0可以是 三次：1.0^3 5.0^3 1.0+5.0^2 二次：1.0^2+5.0 1.0^2 5.0^2 1.0+5.0 一次：1.0 5.0
    val polyExpansion = new PolynomialExpansion()
      .setInputCol("features")
      .setOutputCol("polyFeatures")
      .setDegree(3)

    val polyDF = polyExpansion.transform(df)
    polyDF.show(false)
    // $example off$

    spark.stop()
  }
}

输出结果为：

+---+---------+-----------------------------------------------+
|id |features |Polynomial_features                            |
+---+---------+-----------------------------------------------+
|0  |[1.0,5.0]|[1.0,1.0,1.0,5.0,5.0,5.0,25.0,25.0,125.0]      |
|1  |[2.0,1.0]|[2.0,4.0,8.0,1.0,2.0,4.0,1.0,2.0,1.0]          |
|2  |[4.0,8.0]|[4.0,16.0,64.0,8.0,32.0,128.0,64.0,256.0,512.0]|
+---+---------+-----------------------------------------------+

作者 east

Spark 2月 11,2019

Spark ML机器学习：N-gram

一个n-gram是一个包含n个tokens(如词)的序列。NGram可以将输入特征转换为n-grams。

NGram输入一系列的序列,参数n用来决定每个n-gram的词个数。输出包含一个n-grams序列,每个n-gram表示一个划定空间的连续词序列。如果输入序列包含的词少于n,将不会有输出。
N-Gram认为语言中每个单词只与其前面长度 N-1 的上下文有关。主要分为bigram和trigram，bigram假设下一个词的出现依赖它前面的一个词，trigram假设下一个词的出现依赖它前面的两个词。在SparkML中用NGram类实现，setN(2)为bigram，setN(3)为trigram。


// $example on$
import org.apache.spark.SparkConf
import org.apache.spark.ml.feature.NGram
// $example off$
import org.apache.spark.sql.SparkSession

/**
  * N-Gram认为语言中每个单词只与其前面长度 N-1 的上下文有关。主要分为bigram和trigram，
  * bigram假设下一个词的出现依赖它前面的一个词，trigram假设下一个词的出现依赖它前面的两个词。
  * 在SparkML中用NGram类实现，setN(2)为bigram，setN(3)为trigram。
  */
object NGramExample {
  def main(args: Array[String]): Unit = {
    val sparkConf = new SparkConf();
    sparkConf.setMaster("local[*]").setAppName(this.getClass.getSimpleName)
    val spark = SparkSession
      .builder
      .config(sparkConf)
      .appName("NGramExample")
      .getOrCreate()

    // $example on$
    val wordDataFrame = spark.createDataFrame(Seq(
      (0, Array("Hi", "I", "heard", "about", "Spark")),
      (1, Array("I", "wish", "Java", "could", "use", "case", "classes")),
      (2, Array("Logistic", "regression", "models", "are", "neat"))
    )).toDF("id", "words")

    val ngram = new NGram().setN(2).setInputCol("words").setOutputCol("ngrams")

    val ngramDataFrame = ngram.transform(wordDataFrame)
    ngramDataFrame.select("ngrams").show(false)
    // $example off$

    spark.stop()
  }
}

输出结果：

+——————————————————————+
|ngrams |
+——————————————————————+
|[Hi I, I heard, heard about, about Spark] |
|[I wish, wish Java, Java could, could use, use case, case classes]|
|[Logistic regression, regression models, models are, are neat] |
+——————————————————————+

作者 east

Spark 2月 11,2019

Spark ML机器学习：归一化之最小最大值标准化-MinMaxScaler

MinMaxScaler转换由向量行组成的数据集,将每个特征调整到一个特定的范围(通常是[0,1])。它有下面两个参数:

min:默认是0。转换的下界,被所有的特征共享。
max:默认是1。转换的上界,被所有特征共享。

MinMaxScaler计算数据集上的概要统计数据,产生一个MinMaxScalerModel。然后就可以用这个模型单独的转换每个特征到特定的范围。特征E被转换后的值可以用下面的公式计算:

$$\frac{e_{i} – E_{min}}{E_{max} – E_{min}} * (max – min) + min$$

对于E_{max} == E_{min}的情况,Rescaled(e_i) = 0.5 * (max + min)。

注意,由于0值有可能转换成非0的值,所以转换的输出为DenseVector,即使输入为稀疏的数据也一样。下面的例子展示了如何将特征转换到[0,1]。例子：


// $example on$
import org.apache.spark.SparkConf
import org.apache.spark.ml.feature.MinMaxScaler
import org.apache.spark.ml.linalg.Vectors
// $example off$
import org.apache.spark.sql.SparkSession

object MinMaxScalerExample {
  def main(args: Array[String]): Unit = {
    val sparkConf = new SparkConf();
    sparkConf.setMaster("local[*]").setAppName(this.getClass.getSimpleName)
    val spark = SparkSession
      .builder
      .config(sparkConf)
      .appName("MinMaxScalerExample")
      .getOrCreate()

    // $example on$
    val dataFrame = spark.createDataFrame(Seq(
      (0, Vectors.dense(1.0, 0.1, -1.0)),
      (1, Vectors.dense(2.0, 1.1, 1.0)),
      (2, Vectors.dense(3.0, 10.1, 3.0))
    )).toDF("id", "features")

    val scaler = new MinMaxScaler()
      .setInputCol("features")
      .setOutputCol("scaledFeatures")

    // Compute summary statistics and generate MinMaxScalerModel
    val scalerModel = scaler.fit(dataFrame)

    // rescale each feature to range [min, max].
    val scaledData = scalerModel.transform(dataFrame)
    println(s"Features scaled to range: [${scaler.getMin}, ${scaler.getMax}]")
    scaledData.select("features", "scaledFeatures").show()
    // $example off$

    spark.stop()
  }
}

结果：

+————–+————–+
| features|scaledFeatures|
+————–+————–+
|[1.0,0.1,-1.0]| [0.0,0.0,0.0]|
| [2.0,1.1,1.0]| [0.5,0.1,0.5]|
|[3.0,10.1,3.0]| [1.0,1.0,1.0]|
+————–+————–+

作者 east

Spark 2月 11,2019

Spark ML机器学习：绝对值最大标准化-MaxAbsScaler

数据归一化，以房价预测为案例，房价(y)通常与离市中心距离(x1)、面积(x2)、楼层(x3)有关，设y=ax1+bx2+cx3，那么abc就是我们需要重点解决的参数。但是有个问题，面积一般数值是比较大的，100平甚至更多，而距离一般都是几公里而已，b参数只要一点变化都能对房价产生巨大影响，而a的变化对房价的影响相对就小很多了。显然这会影响最终的准确性，毕竟距离可是个非常大的影响因素啊。所以, 需要使用特征的归一化, 取值跨度大的特征数据, 我们浓缩一下, 跨度小的括展一下, 使得他们的跨度尽量统一。
归一化就是将所有特征值都等比地缩小到0-1或者-1到1之间的区间内。其目的是为了使特征都在相同的规模中。

MaxAbsScaler转换由向量列组成的数据集,将每个特征调整到[-1,1]的范围,它通过每个特征内的最大绝对值来划分。它不会移动和聚集数据,因此不会破坏任何的稀疏性。

MaxAbsScaler计算数据集上的统计数据,生成MaxAbsScalerModel,然后使用生成的模型分别的转换特征到范围[-1,1]。下面是程序调用的例子。


// $example on$
import org.apache.spark.SparkConf
import org.apache.spark.ml.feature.MaxAbsScaler
import org.apache.spark.ml.linalg.Vectors
// $example off$
import org.apache.spark.sql.SparkSession
/*
所有值都扫描一遍，计算出最大最小值，比如1000的话那么absMax=1000。最后返回MaxAbsScalerModel
第一列1.0、2.0、4.0中最小为1.0，最大为4.0，2.0为0.5，第二列0.1、1.0、10.0依次类推
 */

object MaxAbsScalerExample {
  def main(args: Array[String]): Unit = {
    val sparkConf = new SparkConf();
    sparkConf.setMaster("local[*]").setAppName(this.getClass.getSimpleName)
    val spark = SparkSession
      .builder
      .config(sparkConf)
      .appName("MaxAbsScalerExample")
      .getOrCreate()

    // $example on$
    val dataFrame = spark.createDataFrame(Seq(
      (0, Vectors.dense(1.0, 0.1, -8.0)),
      (1, Vectors.dense(2.0, 1.0, -4.0)),
      (2, Vectors.dense(4.0, 10.0, 8.0))
    )).toDF("id", "features")

    val scaler = new MaxAbsScaler()
      .setInputCol("features")
      .setOutputCol("scaledFeatures")

    // Compute summary statistics and generate MaxAbsScalerModel
    val scalerModel = scaler.fit(dataFrame)

    // rescale each feature to range [-1, 1]
    val scaledData = scalerModel.transform(dataFrame)
    scaledData.select("features", "scaledFeatures").show()
    // $example off$

    spark.stop()
  }
}

结果：

+————–+—————-+
| features| scaledFeatures|
+————–+—————-+
|[1.0,0.1,-8.0]|[0.25,0.01,-1.0]|
|[2.0,1.0,-4.0]| [0.5,0.1,-0.5]|
|[4.0,10.0,8.0]| [1.0,1.0,1.0]|
+————–+—————-+

作者 east

月度归档2月 2019