Python一行代码实现滑动窗口

1
2
3
4
5

# 数据的加载
data = np.loads(path)
window_size = 12
# 非常优雅的代码
split_data = data[np.arange(window_size)[None, :] + np.arange(data.shape[0]-window_size)[:, None]]

MySQL数据库总结

版本：8.0

查看会话当前使用的哪个数据库：

1

select database();

设置关闭自动提交事务：

1

set autocommit = 0;

1. 事务的隔离级别

隔离级别总共有四种：

1. 读未提交（Read-Uncommited）
2. 读提交（Read-Commited）解决“脏读”
3. 可重复读（Repeatable-Read）解决“不可重复读”
4. 串行化（Serializable）解决“幻读”

查看当前会话事务的隔离级别：

1

select @@transaction_isolation;

查看数据库的隔离级别：

1

select @@global.transaction_isolation;

1
2
3
4
5
6
7

mysql> select @@global.transaction_isolation;
+--------------------------------+
| @@global.transaction_isolation |
+--------------------------------+
| REPEATABLE-READ                |
+--------------------------------+
1 row in set (0.00 sec)

可见innoDB默认的是可重复读这一隔离级别。可重复读可以避免”不可重读“（innoDB在PR级别通过MVCC解决了幻读这一现象）

排他锁，共享锁

排它锁（Exclusive），又称为X 锁，写锁。

共享锁（Shared），又称为S 锁，读锁。

读写锁之间有以下的关系：

• 一个事务对数据对象O（多行，或者表等等）加了S锁，可以对O进行读取操作，但是不能进行更新（update、delete）操作。加锁期间其它事务能对O加S锁，但是不能加 X 锁。
• 一个事务对数据对象 O 加了 X 锁，就可以对 O 进行读取和更新。加锁期间其它事务不能对 O 加任何锁。

读写锁之间的关系可以概括为：允许多个事务一起读，读写互斥！

但加行锁并不可以解决”幻读“这一现象，因为行锁无法对后insert的数据加锁。幻读指的是当某个事务在读取某个范围内的记录时，另外一个事务又在该范围内插入了新行，当之前的事务再次读取该范围的记录时，会产生幻行。解决幻读要么序列化，要么加表锁。

首先了解两个概念：

• 一致读：consistent read 也叫快照读，当事务开始时会给数据“拍个照”，只要本事务不做update、insert操作，无论其他事务怎样提交，在本事务结束前select查到的内容不会改变。
• 当前读：select * from table_1 for update读取数据库最新的内容

Mysql中主要通过MVCC来保证可重复读，和select级别的幻读。注意：当其他事务进行提交后，本事务要对提交的数据进行修改时，会使用当前读，即update之前先select数据库最新的内容，这就会导致幻读。所以说只保证select级别的幻读，看以下例子：

• A、B事务同时开始
• A事务查询table中的记录，得到一条记录；B事务插入table一条记录，id=2，B事务提交
• A事务当前update id为2的数据，A事务会先查询table中的所有数据，再进行更新。之后查询table中的记录，发现有了两条记录。
• 注意，当不进行更新操作，即使其他事务插入数据并提交，快照读可以保证可重复读，加行锁不可以。

多版本并发控制：multi-versioned concurrency control，是MySQL中基于乐观锁理论实现隔离级别的方式，用于实现读已提交和可重复读取隔离级别的实现。在MySQL中，会在表中每一条数据后面添加两个字段：创建版本号：创建一行数据时，将当前系统版本号作为创建版本号赋值；删除版本号：删除一行数据时，将当前系统版本号作为删除版本号赋值。

2. MySQL索引

2.1 InnoDB引擎

聚集索引，B+树

2.3 MyISAM引擎

叶节点并不存储数据，而是存储指向数据的指针。

非聚集索引

附：在Ubuntu上安装MySQL8.0

请参考：https://computingforgeeks.com/how-to-install-mysql-8-on-ubuntu/

ArrayList源码分析

1. 扩容

Arraylist的初始容量为10，一旦达到，将会按照原容量的50%进行扩容，即elementData数组的长度变为原来的1.5倍。

2.添加元素

我们来看一下add(int index, Object e)这个方法：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22

/**
     * Inserts the specified element at the specified position in this
     * list. Shifts the element currently at that position (if any) and
     * any subsequent elements to the right (adds one to their indices).
     *
     * @param index index at which the specified element is to be inserted
     * @param element element to be inserted
     * @throws IndexOutOfBoundsException {@inheritDoc}
 */
public void add(int index, E element) {
    rangeCheckForAdd(index);
    modCount++;
    final int s;
    Object[] elementData;
    if ((s = size) == (elementData = this.elementData).length)
        elementData = grow();
    System.arraycopy(elementData, index,
                     elementData, index + 1,
                     s - index);
    elementData[index] = element;
    size = s + 1;
}

可以看到，使用了System.arraycopy方法，源数组和目标数组都是elementData，将index及其之后的元素复制到index+1的位置。

3. 序列化

​ 我们发现源码中用于保存元素的elementData的数组是被transient修饰的，这意味着他将不被序列化。那ArrayList是如何序列化的呢？我们可以发现，ArrayList自己实现了两个方法：readObject、writeObject用于自定义序列化，避免采用Java原生的序列化。那为什么要这么做呢？在writeObject方法中，可以看到只是将size范围内的元素进行序列化，这是由于前面讲过的扩容机制，导致elementData的长度大于size，size索引之后都不保存具体元素值（或者说只为数组初始化的值），但确已经申请了内存空间，如果全部序列化，那么将会浪费大量空间来存储这些无用的信息。我们可以通过下面一个例子来具体演示。

​ 我们可以看到，一个长度为20000的数组只保存了5个元素，如果直接将这个数组序列化，大小是79kb，若只将5个元素序列化，序列化后的文件大小仅为1kb。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30

import java.io.FileOutputStream;
import java.io.ObjectOutputStream;

public class SerDemo {
    public static void main(String[] args) {
        int[] nums = new int[20000];
        int size = 5;
        for(int i = 0; i < size; i++){
            nums[i] = i;
        }
        try{
            // 将数组全部初始化
            // FileOutputStream fs = new FileOutputStream("E:\\num1.ser");
            // ObjectOutputStream os = new ObjectOutputStream(fs);
            // os.writeObject(nums);
            // os.close();
            
            // 只将非空数组初始化
            int[] ret = new int[size];
            System.arraycopy(nums, 0, ret, 0, size);
            FileOutputStream fs = new FileOutputStream("E:\\num2.ser");
            ObjectOutputStream os = new ObjectOutputStream(fs);
            os.writeObject(ret);
            os.close();

        }catch(Exception e){
            e.printStackTrace();
        }
    }
}

如何将 int[] 转换为 List

在Java 8及以后版本中，可以这么实现：

1
2
3
4
5
6
7
8
9
10
11
12

import java.util.*;
import java.util.stream.Collectors;

public class Main{
    public static void main(String[] args){
        int[] nums = new int[]{0,1,2,3};
        
        List<Integer> lists = Arrays.stream(nums).boxed().collect(Collectors.toList());
        
        System.out.println(lists);
    }
}

RMLSE损失函数

RMLSE即 $\text{Root Mean Log Squared Error}$

有向图的节点通路

描述：给定有向图的边的集合，设计一个算法，找出两个节点之间是否存在一条通路。

信用卡虚假交易数据检测

测试网站：https://www.lintcode.com/ai/creditcard_fraud/overview

0. 背景介绍

​ 信用卡虚假交易即指该交易有涉嫌非法套现的行为，即用户在商户刷卡后，商户不提供用户消费品而是把消费的钱通过现金的方式返还给用户同时抽取一部分费用作为佣金，虚假交易检测即给定某一交易数据，判定该交易是否是虚假交易。

1. 数据探索

​ 数据集为2013年9月里某两天欧元区的信用卡交易记录。在这两天中共有284807笔交易，其中的492笔是欺诈。把欺诈交易的类(class) 认为是1，非欺诈交易的类认为是0。给定数据集中，正常数据有22万余条，虚假数据只有400多条，可见训练数据严重失衡，需要通过采取一些措施解决这种不平衡。

1.1 数据属性

​ 数据集里面有从PCA转换得到的28个features。之所以进行了PCA转换是因为不能把原始的消费者信用卡记录暴露给公众，这样触犯了用户的隐私。所以做PCA转换处理。可以简单理解为加密。

​ Features V1, V2, …, V28都是经过PCA转换后获得的features。没有被PCA转换的，保留了原始数据是”Time”和”Amount”。”Time”记录了每笔交易和第一笔交易（Time属性为0）之间的时间间隔，以秒为单位。”Amount”是交易数额。”Class”就是这笔交易的最终分类。

1.2 数据分布

​ 导入数据。

1
2
3
4
5
6
7
8
9
10
11
12
13

import pandas as pd
import numpy as np
from matplotlib import pyplot as plt
import seaborn as sns

#训练模型的数据集
df = pd.read_csv('ml_problems_12_creditcard_train.csv')
df = df.drop(["Id"],axis=1)

#加载测试数据,需要预测的
test = pd.read_csv('ml_problems_12_creditcard_test.csv')
Id = test.Id
test = test.drop(["Id"], axis=1)

​ 我们首先统计在不同的时间间隔内正常交易的数量和虚假交易的数量是怎样的。

1
2
3
4
5
6
7
8
9
10
11
12

f, (ax1, ax2) = plt.subplots(2, 1, sharex=True, figsize=(12, 4))
bins = 100

ax1.hist(df.Time[df.Class==1], bins=bins)
ax1.set_title("Fraud")

ax2.hist(df.Time[df.Class==0], bins=bins)
ax2.set_title("Normal")

plt.xlabel('Time')
plt.ylabel('Number of Transactions')
plt.show()

​ 可以看到，正常交易有一个明显的周期性，而虚假交易呈现一个均匀分布的趋势。

​ 我们再统计不同交易金额的交易数量。

1
2
3
4
5
6
7
8
9
10
11
12
13

f, (ax1, ax2) = plt.subplots(2, 1, sharex=True, figsize=(12, 4))
bins = 25

ax1.hist(df.Amount[df.Class==1], bins=bins)
ax1.set_title("Fraud")

ax2.hist(df.Amount[df.Class==0], bins=bins)
ax2.set_title("Normal")

plt.xlabel('Amount')
plt.ylabel('Number of Transactions')
plt.yscale("log")
plt.show()

​

​ 可以看到，正常交易的交易金额比虚假交易金额要大，虚假交易的交易金额最大不超过2500。

2. 数据清洗

2.1 数据标准化

​ 首先将“Time”、“Amount”这两列标准化，需要注意的是，训练数据标准化意味着测试数据集也需要标准化，要将二者置于同一尺度下才能较好的预测结果。注意：标准化的时候注意防止数据泄露！

• 先将数据划分为训练集和测试集

1
2
3
4
5
6

from sklearn.model_selection import train_test_split

X = df.iloc[:, df.columns != 'Class']
y = df.iloc[:, df.columns == 'Class']

X_train,X_test,y_train,y_test = train_test_split(X,y,test_size=0.25,random_state=0)

• 数据标准化

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19

from sklearn.preprocessing import StandardScaler

amount_scaler = StandardScaler()
time_scaler = StandardScaler()

X_train["normAmount"] = amount_scaler.fit_transform(X_train['Amount'].values.reshape(-1,1))
X_train["normTime"] = time_scaler.fit_transform(X_train['Time'].values.reshape(-1,1))

X_train = X_train.drop(["Time","Amount"], axis=1)

#利用训练集得到的归一化器对测试集进行归一化转化
X_test["normAmount"] = amount_scaler.transform(X_test['Amount'].values.reshape(-1,1))
X_test["normTime"] =  time_scaler.transform(X_test['Time'].values.reshape(-1,1))
X_test = X_test.drop(["Time","Amount"], axis = 1)

test["normAmount"] = amount_scaler.transform(test['Amount'].values.reshape(-1,1))
test["normTime"] =  time_scaler.transform(test['Time'].values.reshape(-1,1))
test = test.drop(["Time","Amount"], axis = 1)
test_data = np.array(test)

2.2 解决样本不平衡问题

​ 对于样本类别数量极不平衡通常有过采样（over-sampling）、欠采样（under-sampling）两种方法。过采样用于扩增数据集，而欠采样用于减小数据集。

​ 本例中，由于预测的数据在5万条，给定的训练数据中异常数据只有400条左右，如果做欠采样，需要使得正常数据与虚假数据数量相同，那么训练模型的数据大约为900条，这样训练出的模型大概率是欠拟合的，无法应对大规模测试集的情况。

​ 因此，采用SMOTE算法对数据集进行过采样，使得虚假交易数据与正常交易数据相同。

1
2
3
4
5

from imblearn.over_sampling import SMOTE

sample_solver = SMOTE(random_state=0)
# 对训练集进行过采样操作
X_samples,y_samples = sample_solver.fit_resample(X_train,y_train)

3. 模型选择

​ 模型尝试了LR、决策树、随机森林、XGBClassifier。最终随机森林在数据集上取得的分数最高为0.87。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

from sklearn.ensemble import RandomForestClassifier

X_samples,y_samples = np.array(X_samples), np.array(y_samples)

classifier = RandomForestClassifier(random_state=0)
classifier.fit(X_samples, y_samples.ravel())

y_pred = classifier.predict(X_test)
from sklearn.metrics import f1_score,confusion_matrix
cm_grid = confusion_matrix(y_test,y_pred)
sns.heatmap(cm_grid, annot=True)
f1_score(y_true=y_test, y_pred=y_pred)

pred = classifier.predict(test_data)
pred.sum()

由于随机的原因分数误差在0.1上下。

机器学习常见模型优缺点对比

1. 支持向量机与LR

1.1 支持向量机优点分析

• 有着完备的数学统计基础
• 决策超平面只与支持向量有关，且得到的决策超平面是最大化间隔实现的，鲁棒性较高

1.2 支持向量机缺点分析

• 当数据量较大维度较高时，训练缓慢
• 面对多分类问题，支持向量机不能够很好的处理

1.3 LR优点分析

• 易于训练

1.4 LR缺点分析

• 只能处理非线性数据
• 对多重共线性数据效果较差

2. k均值聚类与DBSCAN

2.1 k均值聚类的优缺点分析

​ 优点：

• 直观简单，易于实现
• 收敛速度较快

​ 缺点：

• 容易受到异常值影响
• 最终聚类结果容易受到初始聚类中心的选择的影响
• K的选择需要不断尝试
• 最终只能收敛到局部最优值
• 只适用于球状（凸集）数据

2.2 DBSCAN优缺点分析

​ 优点：

• 对异常值不敏感
• 可以发现任意形状的类簇
• 无需指定k的数量

​ 缺点：

• 当类与类之间的间隔较大或密度不均匀的时候，效果不太好
• 当数据较大时，时间复杂度较高

3. 随机森林与决策树

3.1 随机森林的优点

• 对于大部分的数据，它的分类效果比较好。
• 能处理高维特征，并且不用做特征选择，不容易产生过拟合
• 容易实现并行化计算
• 对数据集的适应能力强：既能处理离散型数据，也能处理连续型数据，数据集无需规范化。
• 即使有很大部分数据遗失，仍可以维持高准确度

3.2 随机森林的缺点

• 训练相比决策树而言慢
• 在某些噪音比较大的样本集上，RF的模型容易陷入过拟合
• 对于许多统计建模者来说，随机森林给人的感觉就像一个黑盒子，你无法控制模型内部的运行。只能在不同的参数和随机种子之间进行尝试。

并查集

1. 并查集介绍

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17

int[] data = new int[10];
public int find(int x){
    if(data[x] == x){
        return x;
    }else{
        data[x] = find(data[x]);
        return data[x];
    }
}

public voif merge(int a, int b){
    int x = find(a);
    int y = find(b);
    if(x != y){
        data[x] = y;
    }
}

Hadoop 完全分布式集群配置