Wyundi’s Blog

Ubuntu环境配置

2020-07-19T18:38:00+00:00

Ubuntu 环境配置相关问题

目录：

Ubuntu ibus输入法无法按数字键取词问题
GitHub 添加ssh密钥
Anaconda配置
GRUB2引导顺序调整
gcc版本降级
GPG error: The following signatures couldn’t be verified because the public key is not available.

Ubuntu ibus输入法无法按数字键取词问题

参考：

ubuntu自带输入法ibus 无法按数字键取词

操作系统：Ubuntu 18.04

rm -rf ~/.cache/ibus/libpinyin 有个人习惯词先备份user_bigram.db 重启 ibus restart

GitHub 添加ssh密钥

生成ssh key

$ ssh-keygen -t rsa -C "you@example.com"

密钥存储位置: ~/.ssh/id_rsa.pub
GitHub上添加密钥

Anaconda配置

安装

$ bash Anaconda3-2020.02-Linux-x86_64.sh

anaconda自动进入虚拟环境base

解决方法:

$ conda config --set auto_activate_base false

创建虚拟环境失败（代理问题）：

解决方法;

向 ~/.bashrc 中添加：

$ export all_proxy="socks5://127.0.0.1:1080"

创建虚拟环境

注意要写明python版本，否则虚拟环境中没有python

$ conda create -n <env-name> python=3.7

conda安装opencv

$ conda install -c menpo opencv

或者

$ conda install py-opencv

虚拟环境中调用opencv-python报错：error: (-2:Unspecified error) The function is not implemented.

```
$ conda uninstall py-opencv
```
PYPI官网下载适当版本的opencv，此处为
- opencv_python-4.3.0.36-cp37-cp37m-manylinux2014_x86_64.whl

$ pip3 install opencv_python-4.3.0.36-cp37-cp37m-manylinux2014_x86_64.whl

虚拟环境中使用 pip3 install 报错：Missing dependencies for SOCKS support

```
$ conda install pysocks
```

GRUB2引导顺序调整

修改 /etc/default/grub 中的 GRUB_DEFAULT
使用以下命令更新菜单
- ```
$ sudo update-grub2
```

gcc版本降级

Ubuntu20.04自带gcc版本为gcc9，但CUDA编程需要gcc7环境，故将其降级
安装gcc7
```
$ sudo apt install gcc-7 g++-7
```

进行版本切换（改变优先级）

$ sudo update-alternatives --install /usr/bin/gcc gcc /usr/bin/gcc-7 100
$ sudo update-alternatives --install /usr/bin/gcc gcc /usr/bin/gcc-9 50

查看优先级

$ sudo update-alternatives --config gcc

查看当前版本
```
$ gcc -v
```

GPG error: The following signatures couldn’t be verified because the public key is not available.

sudo apt update 出现该问题

解决方法：

$ sudo gpg --keyserver keyserver.ubuntu.com --recv <your public key>					#plic key 根据错误提示写
$ sudo gpg --export --armor <your public key> | sudo apt-key add -

Tensorflow & CUDA

2020-06-28T14:35:00+00:00

pip环境和conda环境中TensorFlow及对应版本的CUDA和cuDNN的安装

环境：

操作系统：Ubunty 20.04

GPU：RTX2080Ti x2

python：3.7

pip环境

CUDA:

在官网下载cuda_10.0.130_410.48_linux.run
在ubuntu20.04中，系统自带gcc版本高于CUDA要求的版本，安装时跳过版本检查即可
- ```
$ sudo bash cuda_10.0.130_410.48_linux.run --override
```

安装完成以后添加CUDA到环境变量

向 ~/.bashrc 中添加：
	export  PATH=/usr/local/cuda-10.0/bin:$PATH
	export  LD_LIBRARY_PATH=/usr/local/cuda-10.0/lib64$LD_LIBRARY_PATH
    
然后在终端： source ~/.bashrc

nvcc -V 可以查看CUDA版本，检查是否正确安装

cuDNN:

解压到当前目录

$ tar -xzvf cudnn-10.0-linux-x64-v7.6.5.32.tgz

复制cuDNN头文件

$ sudo cp cuda/include/* /usr/local/cuda-10.0/include/

复制cuDNN库

$ sudo cp cuda/lib64/* /usr/local/cuda-10.0/lib64/

添加可执行权限

$ sudo chmod +x /usr/local/cuda-10.0/include/cudnn.h
$ sudo chmod +x /usr/local/cuda-10.0/lib64/libcudnn*

校验是否安装成功

$ cat /usr/local/cuda/include/cudnn.h | grep CUDNN_MAJOR -A 2

成功则会出现如下信息：

#define CUDNN_MAJOR 7
#define CUDNN_MINOR 6
#define CUDNN_PATCHLEVEL 5
--
#define CUDNN_VERSION (CUDNN_MAJOR * 1000 + CUDNN_MINOR * 100 + CUDNN_PATCHLEVEL)
    
#include "driver_types.h"

tensorflow:

$ sudo pip3 install tensorflow-gpu==2.0.0beta0

conda环境

$ conda install cudatoolkit=10.1
$ conda install cudnn=7.6
$ conda install tensorflow-gpu=2.1

Keras卷积神经网络

2020-01-17T15:25:00+00:00

基于Keras的卷积神经网络

参考：

Keras官方文档

Keras中文文档

环境：

操作系统：Ubuntu 18.04

CUDA: 10.0

TensorFLow: 1.13

Keras: 2.3.1

Keras构建卷积神经网络

使用Keras构建卷积神经网络, 并将训练模型保存.
加载模型, 用于预测新图片

构建网络

#!/usr/bin/env python
# -*- coding:utf-8 -*-

from keras.models import Sequential
from keras.layers.core import Dense, Dropout, Flatten, Activation
from keras.layers.convolutional import Conv2D
from keras.layers.pooling import MaxPooling2D
from keras import backend as K
from keras.utils import np_utils
from keras.models import load_model

import keras.layers
import numpy as np
import matplotlib.pyplot as plt

path = "/home/wyundi/Project/Git/MachineLearning/Keras/Tutorial/mnist"

# 获取数据集 
x_train = np.load(path + "/data/x_train.npy")
y_train = np.load(path + "/data/y_train.npy")
x_test = np.load(path + "/data/x_test.npy")
y_test = np.load(path + "/data/y_test.npy")

print(x_train.shape, y_train.shape)

# 显示图片
'''
plt.figure()
plt.imshow(x_train[20])
plt.show()
'''

# channles_last
img_rows, img_cols = x_train.shape[1], x_train.shape[2]

if K.image_data_format() == 'channels_first':
    ori_shape = (1, img_rows, img_cols)
else:
    ori_shape = (img_rows, img_cols, 1)

# 数据预处理
x_train = x_train.reshape((x_train.shape[0],)+ori_shape)
x_test = x_test.reshape((x_test.shape[0],)+ori_shape)

x_train, x_test = x_train / 255.0, x_test / 255.0

# one-hot编码
classes = 10
y_train = np_utils.to_categorical(y_train, classes)
y_test = np_utils.to_categorical(y_test, classes)

# 设置模型参数
filters = 32
kernel_size = (3,3)
pool_size = (2,2)
epochs = 5
batch_size = 128

# 构建模型
model = Sequential([
    # 第一层卷积
    Conv2D(filters, kernel_size=kernel_size, input_shape=ori_shape, activation='relu'),
    MaxPooling2D(pool_size=pool_size),
    # 第二层卷积
    Conv2D(filters//2, kernel_size=kernel_size, activation='relu'),
    MaxPooling2D(pool_size=pool_size),
    Dropout(0.5),
    # 全连接层
    Flatten(),
    Dense(128, activation='relu'),
    Dropout(0.5),
    # 输出层
    Dense(classes),
    Activation('softmax')
])

model.compile(optimizer='adam',
              loss='categorical_crossentropy',
              metrics=['accuracy'])

# 训练并验证模型
model.fit(x_train, y_train, batch_size=batch_size, epochs=epochs, validation_split=0.05)

loss, acc = model.evaluate(x_test, y_test, verbose=1)
print("Loss: ", loss)
print("Accuracy: ", acc)

# 模型结构
model.summary()

# 保存模型
model.save(path + "/models/mnist_CNN.h5") 
save_path = path + "/models/mnist_CNN.h5"
print("Save path: ", save_path)

返回结果

Using TensorFlow backend.
(60000, 28, 28) (60000,)
WARNING:tensorflow:From /usr/local/lib/python3.6/dist-packages/tensorflow/python/ops/resource_variable_ops.py:435: colocate_with (from tensorflow.python.framework.ops) is deprecated and will be removed in a future version.
Instructions for updating:
Colocations handled automatically by placer.
WARNING:tensorflow:From /usr/local/lib/python3.6/dist-packages/tensorflow/python/ops/math_ops.py:3066: to_int32 (from tensorflow.python.ops.math_ops) is deprecated and will be removed in a future version.
Instructions for updating:
Use tf.cast instead.
2020-01-17 19:17:00.826600: I tensorflow/core/platform/cpu_feature_guard.cc:141] Your CPU supports instructions that this TensorFlow binary was not compiled to use: AVX2 FMA
2020-01-17 19:17:00.847100: I tensorflow/core/platform/profile_utils/cpu_utils.cc:94] CPU Frequency: 2893305000 Hz
2020-01-17 19:17:00.847476: I tensorflow/compiler/xla/service/service.cc:150] XLA service 0x2a03750 executing computations on platform Host. Devices:
2020-01-17 19:17:00.847508: I tensorflow/compiler/xla/service/service.cc:158]   StreamExecutor device (0): <undefined>, <undefined>
Train on 57000 samples, validate on 3000 samples
Epoch 1/5
57000/57000 [==============================] - 28s 489us/step - loss: 0.6047 - accuracy: 0.8037 - val_loss: 0.0893 - val_accuracy: 0.9780
Epoch 2/5
57000/57000 [==============================] - 27s 471us/step - loss: 0.2332 - accuracy: 0.9293 - val_loss: 0.0611 - val_accuracy: 0.9847
Epoch 3/5
57000/57000 [==============================] - 27s 469us/step - loss: 0.1834 - accuracy: 0.9438 - val_loss: 0.0522 - val_accuracy: 0.9880
Epoch 4/5
57000/57000 [==============================] - 26s 447us/step - loss: 0.1543 - accuracy: 0.9521 - val_loss: 0.0459 - val_accuracy: 0.9873
Epoch 5/5
57000/57000 [==============================] - 27s 474us/step - loss: 0.1381 - accuracy: 0.9571 - val_loss: 0.0412 - val_accuracy: 0.9903
10000/10000 [==============================] - 1s 143us/step
Loss:  0.042725288298050876
Accuracy:  0.9861999750137329
Model: "sequential_1"
_________________________________________________________________
Layer (type)                 Output Shape              Param #   
=================================================================
conv2d_1 (Conv2D)            (None, 26, 26, 32)        320       
_________________________________________________________________
max_pooling2d_1 (MaxPooling2 (None, 13, 13, 32)        0         
_________________________________________________________________
conv2d_2 (Conv2D)            (None, 11, 11, 16)        4624      
_________________________________________________________________
max_pooling2d_2 (MaxPooling2 (None, 5, 5, 16)          0         
_________________________________________________________________
dropout_1 (Dropout)          (None, 5, 5, 16)          0         
_________________________________________________________________
flatten_1 (Flatten)          (None, 400)               0         
_________________________________________________________________
dense_1 (Dense)              (None, 128)               51328     
_________________________________________________________________
dropout_2 (Dropout)          (None, 128)               0         
_________________________________________________________________
dense_2 (Dense)              (None, 10)                1290      
_________________________________________________________________
activation_1 (Activation)    (None, 10)                0         
=================================================================
Total params: 57,562
Trainable params: 57,562
Non-trainable params: 0
_________________________________________________________________
Save path:  /home/wyundi/Project/Git/MachineLearning/Keras/Tutorial/mnist/models/mnist_CNN.h5

使用保存的模型预测新图片

#!/usr/bin/env python
# -*- coding:utf-8 -*-

from keras import backend as K
from keras.models import load_model

import numpy as np
import matplotlib.pyplot as plt

path = "/home/wyundi/Project/Git/MachineLearning/Keras/Tutorial/mnist"

# 获取数据集 
x_train = np.load(path + "/data/x_train.npy")
y_train = np.load(path + "/data/y_train.npy")
x_test = np.load(path + "/data/x_test.npy")
y_test = np.load(path + "/data/y_test.npy")

# 显示图片

plt.figure()
plt.imshow(x_train[20])
# plt.show()

# channles_last
img_rows, img_cols = x_train.shape[1], x_train.shape[2]

if K.image_data_format() == 'channels_first':
    ori_shape = (1, img_rows, img_cols)
else:
    ori_shape = (img_rows, img_cols, 1)

# 数据预处理
x_train = x_train.reshape((x_train.shape[0],)+ori_shape)
x_test = x_test.reshape((x_test.shape[0],)+ori_shape)

x_train, x_test = x_train / 255.0, x_test / 255.0

print(x_train.shape, y_train.shape)

# 加载模型
model = load_model(path + "/models/mnist_CNN.h5")

model.summary()

# 整理图片尺寸
x_pri = x_test[0]
x_pri = x_pri.reshape((1,) + ori_shape)
print(x_pri.shape)

# 预测
print("Predict: ", np.argmax(model.predict(x_pri)))
print("Label: ", y_test[0])

预测结果

Using TensorFlow backend.
(60000, 28, 28, 1) (60000,)
WARNING:tensorflow:From /usr/local/lib/python3.6/dist-packages/tensorflow/python/ops/resource_variable_ops.py:435: colocate_with (from tensorflow.python.framework.ops) is deprecated and will be removed in a future version.
Instructions for updating:
Colocations handled automatically by placer.
2020-01-17 19:22:16.737457: I tensorflow/core/platform/cpu_feature_guard.cc:141] Your CPU supports instructions that this TensorFlow binary was not compiled to use: AVX2 FMA
2020-01-17 19:22:16.759050: I tensorflow/core/platform/profile_utils/cpu_utils.cc:94] CPU Frequency: 2893305000 Hz
2020-01-17 19:22:16.759443: I tensorflow/compiler/xla/service/service.cc:150] XLA service 0x25a9620 executing computations on platform Host. Devices:
2020-01-17 19:22:16.759475: I tensorflow/compiler/xla/service/service.cc:158]   StreamExecutor device (0): <undefined>, <undefined>
WARNING:tensorflow:From /usr/local/lib/python3.6/dist-packages/tensorflow/python/ops/math_ops.py:3066: to_int32 (from tensorflow.python.ops.math_ops) is deprecated and will be removed in a future version.
Instructions for updating:
Use tf.cast instead.
Model: "sequential_1"
_________________________________________________________________
Layer (type)                 Output Shape              Param #   
=================================================================
conv2d_1 (Conv2D)            (None, 26, 26, 32)        320       
_________________________________________________________________
max_pooling2d_1 (MaxPooling2 (None, 13, 13, 32)        0         
_________________________________________________________________
conv2d_2 (Conv2D)            (None, 11, 11, 16)        4624      
_________________________________________________________________
max_pooling2d_2 (MaxPooling2 (None, 5, 5, 16)          0         
_________________________________________________________________
dropout_1 (Dropout)          (None, 5, 5, 16)          0         
_________________________________________________________________
flatten_1 (Flatten)          (None, 400)               0         
_________________________________________________________________
dense_1 (Dense)              (None, 128)               51328     
_________________________________________________________________
dropout_2 (Dropout)          (None, 128)               0         
_________________________________________________________________
dense_2 (Dense)              (None, 10)                1290      
_________________________________________________________________
activation_1 (Activation)    (None, 10)                0         
=================================================================
Total params: 57,562
Trainable params: 57,562
Non-trainable params: 0
_________________________________________________________________
(1, 28, 28, 1)
Predict:  7
Label:  7

Keras基础

2020-01-17T10:30:00+00:00

Keras基础结构
以mnist数据库为例构建Keras神经网络

参考：

dropout中noise_shape参数的作用

环境：

操作系统：Ubuntu 18.04

CUDA: 10.0

TensorFLow: 1.13

Keras: 2.3.1

Keras构建神经网络框架

Sequential model (顺序模型)

顺序模型是多个神经网络层的堆叠.

构建方法:

1. 将网络层构建成列表, 作为参数传入model.Sequential()
 	2. 创建空的Sequential模型后使用model.add()方法向其中添加层

from keras.models import Sequential
from keras.layers import Dense, Activation

# 方法1
model = Sequential([
    Dense(32, input_shape=(784,)),
    Activation('relu'),
    Dense(10),
    Activation('softmax'),
])

# 方法2
model = Sequential()
model.add(Dense(32, input_dim=784))
model.add(Activation('relu'))

设定输入数据维数

向Sequential模型添加网络层时, 需要在第一层定义输入数据的维数. (仅在第一层需要, 因为后面的层可以自动获取前一层的输出维度)

有以下几种方法:

在第一层的参数中定义, input_shape = (x, y)
类似Dense这种2维的层支持通过参数input_dim指定输入尺寸. 某些3维层支持input_dim和input_length参数
如果需要为输入的数据指定一个固定的batch大小, 可以给层传递一个参数batch_size. 例如: 在第一层的参数中包含 (batch_size = 32, input_shape=(6, 8)), 那么每一批输入第一层的数据维度就是(32, 6, 8)

因此, 下面两种方法是等价的:

# 方法1
model = Sequential()
model.add(Dense(32, input_shape=(784,)))

# 方法2
model = Sequential()
model.add(Dense(32, input_dim=784))

模型编译

在训练模型之前, 需要配置学习过程. 这个过程通过compile方法完成. 他接收三个参数:

这三个参数可以是现有优化器的字符串标识符, 也可以是具体的函数.

# 多分类问题
model.compile(optimizer='rmsprop',
              loss='categorical_crossentropy',
              metrics=['accuracy'])

# 二分类问题
model.compile(optimizer='rmsprop',
              loss='binary_crossentropy',
              metrics=['accuracy'])

# 均方误差回归问题
model.compile(optimizer='rmsprop',
              loss='mse')

# 自定义评估标准函数
import keras.backend as K

def mean_pred(y_true, y_pred):
    return K.mean(y_pred)

model.compile(optimizer='rmsprop',
              loss='binary_crossentropy',
              metrics=['accuracy', mean_pred])

模型训练和验证

使用model.fit()进行模型训练. fit函数的参数包括训练集数据,标签等

使用model.evaluate()进行模型验证, 参数使用测试集数据和标签.

参数versbose用于设置日志现实方式:

0: 不在标准输出流输出日志信息
1: 输出进度条记录
2: 每个epoch输出一行记录

# 训练模型，以 32 个样本为一个 batch 进行迭代
model.fit(data, labels, epochs=10, batch_size=32)

# 模型验证
model.evaluate(x_test, y_test, verbose=2)

模型

自定义模型

给定输入和输出的的张量, 可以创建一个新的模型:

from keras.models import Model
from keras.layers import Input, Dense

a = Input(shape=(32,))
b = Dense(32)(a)
model = Model(inputs=a, outputs=b)

对于多个输入和输出数据, 可以使用列表进行创建:

model = Model(inputs=[a1, a2], outputs=[b1, b2, b3])

核心网络层

常用核心层包括 Dense/Activation/Dropout/Flatten. 其余核心层查看官方文档.

Dense

全连接层. 实现以下操作:

output = activation(dot(input, kernel) + bias)

其中, activation是激活函数, kernal和bias分别是由网络层创建的权重矩阵和偏置向量.

参数:

units: 正整数，输出空间维度。
activation: 激活函数 (详见 activations)。若不指定，则不使用激活函数 (即，「线性」激活: a(x) = x)。
use_bias: 布尔值，该层是否使用偏置向量。
kernel_initializer: kernel 权值矩阵的初始化器 (详见 initializers)。
bias_initializer: 偏置向量的初始化器 (see initializers).
kernel_regularizer: 运用到 kernel 权值矩阵的正则化函数 (详见 regularizer)。
bias_regularizer: 运用到偏置向的的正则化函数 (详见 regularizer)。
activity_regularizer: 运用到层的输出的正则化函数 (它的 “activation”)。 (详见 regularizer)。
kernel_constraint: 运用到 kernel 权值矩阵的约束函数 (详见 constraints)。
bias_constraint: 运用到偏置向量的约束函数 (详见 constraints)。

Activation

激活函数. 输入尺寸和输出尺寸一致, 都和上一层的输出尺寸相同.

keras.layers.Activation(activation)

Dropout

按比例将输入下一层的数据随机设置为0. 有助于防止过拟合.

参数:

rate: 丢弃数据的比例, 范围0-1
noise_shape: dropout中noise_shape参数的作用
seed: 作为随机种子的python整数

Flatten

将输入层展平, 不影响批量的大小

参数:

data_format：一个字符串，其值为 channels_last（默认值）或者 channels_first。它表明输入的维度的顺序。此参数的目的是当模型从一种数据格式切换到另一种数据格式时保留权重顺序。channels_last 对应着尺寸为 (batch, ..., channels) 的输入，而 channels_first 对应着尺寸为 (batch, channels, ...) 的输入。默认为 image_data_format 的值，你可以在 Keras 的配置文件 ~/.keras/keras.json 中找到它。如果你从未设置过它，那么它将是 channels_last

model = Sequential()
model.add(Conv2D(64, (3, 3),
                 input_shape=(3, 32, 32), padding='same',))
# 现在：model.output_shape == (None, 64, 32, 32)

model.add(Flatten())
# 现在：model.output_shape == (None, 65536)

构建mnist神经网络

#!/usr/bin/env python
# -*- coding:utf-8 -*-

from keras.models import Sequential
import keras.layers

import numpy as np

path = ".../mnist/data"

# 获取数据集 
x_train = np.load(path + "/x_train.npy")
y_train = np.load(path + "/y_train.npy")
x_test = np.load(path + "/x_test.npy")
y_test = np.load(path + "/y_test.npy")

print(x_train.shape, y_train.shape)

# 数据归一化
x_train, x_test = x_train / 255.0, x_test / 255.0

# 构建模型
model = Sequential([
    keras.layers.Flatten(input_shape=(28, 28)),
    keras.layers.Dense(128, activation='relu'),
    keras.layers.Dropout(0.2),
    keras.layers.Dense(10, activation='softmax')
])

model.compile(optimizer='adam',
              loss='sparse_categorical_crossentropy',
              metrics=['accuracy'])

# 训练并验证模型
model.fit(x_train, y_train, epochs=5)

model.evaluate(x_test, y_test, verbose=1)

# 模型结构
model.summary()

# 预测
print(np.argmax(model.predict(x_test)[0]), y_test[0])

Machine Learning: 神经网络

2019-04-10T10:54:00+00:00

全连接神经网络基础及相关数学计算。

Machine Learning: 神经网络

参考：

Machine Learning小结(1)：线性回归、逻辑回归和神经网络

CS231n课程笔记翻译：神经网络笔记1（上）

机器学习（五）- 对于cost function的思考

环境：

操作系统：Ubuntu 18.04

神经网络绘图：NN-SVG

神经网络（Neural Network）

从线性回归和逻辑回归说起

先给出线性回归和逻辑回归的模型：

线性回归：

\[h = \theta^Tx\]

逻辑回归：

\[z(x) = \theta^Tx\] \[h(x) = \sigma(z)\]

在这两个模型中都包含$\theta^Tx$。在线性回归中，这个方程表示对实际数据走向的预测。而在逻辑回归中，这个方程表示数据的决策边界。如果数据图像或数据边界近似为一条直线，则可以用一次函数对其进行预测，如果图像近似为一条曲线，就需要用高幂次的方程替换一次函数，才能产生较好的效果。比如，图像近似为一个圆形，就需要用类似：

\[h_\theta(x) = g(\theta_0 + \theta_1x1 + \theta_2x2 + \theta_3x_1^2 + \theta_4x_2^2)\]

这样的圆方程来对其进行预测。我们可以使用非常复杂的模型对数据分布进行预测，或者来适应复杂的决策边界。

但无论是线性回归还是逻辑回归，当特征太多时，计算负荷都会非常大。如果我们有100个特征，并希望用这些特征构建一个非线性的模型，就需要数量非常惊人的特征组合。即使只采用两两组合（$x_1x_2, x_2x_3,…x_{99}x_{100}$），也会有接近5000个特征。这对于一个简单模型来说太多了。这时候我们需要神经网络。

神经网络结构

生物的神经中枢进行思考需要进行以下几个步骤：

外部刺激通过神经末梢，转化为电信号，传导到神经细胞（神经元）。

无数神经元构成神经中枢。

神经中枢综合各种信号，作出判断。

基于对神经元的模拟，建立了称为“感知器”的模型：

图中的圆圈即代表神经元（感知器）。它接受多个输入（$x_1, x_2, x_3$），并产生一个输出（$output$）。

多个神经元构成神经网络（神经中枢）：

图中每一个圆圈代表一个神经元，所有的神经元相互连接，构成神经网络。这个神经网络接受5个外部输入，数据经过神经网络处理后获得一个输出。

逻辑回归和神经网络

逻辑回归可以看作是一个非常小的神经网络。逻辑回归模型接受输入以后，首先要对数据赋予权重（weight）和偏置（bias），然后使用激活函数（$\alpha(z)$）对其进行激活，并将结果作为输出值。这个过程和神经元的运算过程是一样的，区别只是使用的激活函数不同，所以可以将逻辑回归模型看作是一个只包含一个神经元的神经网络。对于大规模的神经网络，只需要将多个类似逻辑回归的神经元组合在一起即可。

将三个神经元堆叠在一起，然后将其输出作为另一个神经元的输入值，即可产生一个基础的神经网络。

直观理解

从本质上讲，神经网络能够通过学习得出其自身的一系列特征。在普通的逻辑回归中，我们被限制使用数据中的原始特征$x_1, x_2, x_3, …, x_n$，虽然我们可以使用一些二项式来组合这些特征，但仍受这些原始特征的限制，无法表示所有可能的情况。在神经网络中，原始特征只作为输入层，只有第一层神经网络直接利用原始特征作为数据。从第二层开始，所有后面的神经网络的基础数据都是前一层通过学习后得出的新特征，即不受原始特征的限制。所以，更深的神经网络可以学到更多的特征，模拟更复杂的函数。

神经网络中，单个神经元可以表示简单逻辑运算 (and/or/not)。

对于AND运算：

\[input = x_1, x_2 \in \{0, 1\} \\ output = x_1 \ AND \ x_2\]

其中，令$\theta_0 = -3$，$\theta_1 = 2$ ，$\theta_2 = 2$，则$h_{\theta}(x) = sigmoid(-3 + 2x_1 + 2x_2)$。

则有真值表：

$x_1$	$x_2$	$h_{\theta}(x)$
0	0	0
0	1	0
1	0	0
1	1	1

可以看出，$h_{\theta}(x) = x_1 \ AND \ x_2$。

同样：

对于OR运算：取$\theta_0 = -1$，$\theta_1 = 2$ ，$\theta_2 = 2$，则$h_{\theta}(x) = sigmoid(-1 + 2x_1 + 2x_2) = x_1 \ OR \ x_2$；

对于NOT运算：取$\theta_0 = 1$，$\theta_1 = -2$，则$h_{\theta}(x) = sigmoid(1 - 2x_1) = NOT \ x_1$。

但如果只使用一个神经元，就无法表示复杂的逻辑运算，例如同或 (XNOR)，因为同或不是一个线性可分结构。构造XNOR运算需要使用神经网络。

XNOR运算逻辑如下：

\[XNOR = (x_1 \ AND \ x_2)OR((NOT \ x_1)AND(NOT \ x_2))\]

首先构造一个能表达$((NOT \ x_1)AND(NOT \ x_2))$部分的神经元，取$\theta_0 = 3$，$\theta_1 = -2$ ，$\theta_2 = -2$，则$h_{\theta}(x) = sigmoid(3 - 2x_1 - 2x_2) = (NOT \ x_1)AND(NOT \ x_2)$。

然后将该神经元的结果和AND神经元的结果作为输入值构建OR神经元，即可得到能表示XNOR运算的神经网络。

其中，隐藏层的两个神经元即为$((NOT \ x_1)AND(NOT \ x_2))$部分和AND部分。

通过这种方法，我们就可以构建更复杂的神经网络来模拟更复杂的函数关系。

神经网络的表示

在上图的神经网络中，共包含（$ x_1, x_2, x_3 $）三个输入变量，他们竖直的堆叠起来成为一层，这是神经网络的输入层。中间四个神经元所产生的结果直接传入下一层的节点中，在训练过程中我们看不到他们产生的结果，所以将他们称为隐藏层。最后一个结点接受隐藏层四个节点的数据，产生最后的结果，这一层称为输出层，它负责产生预测值。通常我们将输入层称为第零层，所以隐藏层为第一层，输出层为第二层。这个神经网络是一个两层的神经网络。

将左侧三个数据（$x_1, x_2, x_3 $）作为输入值，中间四个神经元堆叠在一起成为神经网络的第一层。使用上角标 $X^{[layers] (sample)}$ 分别表示数据在神经网络的第几层/这是第几个样本，下角标 $X_{[features]}$ 表示数据是该层第几个特征。

例如，$x^{[1] (5)}_3$ 表示这个数据是第第一层的第五个样本中第三个特征。

用$a^{[0]}$来表示输入特征。$a$表示激活的意思，它意味着网络中本层的值会传递到下一层。输入层将x传递给隐藏层，所以将输入层的激活值称为$a^{[0]}$。下一层隐藏层同样会产生激活值，将其记为$a^{[1]}$。按同样的规则，将每层线性方程的结果记为$z$，参数记为$\theta$，或$W$和$b$。

神经网络计算

数据向量化

为方便计算同时提高运算速度，将所有数据合并为矩阵统一进行运算。对于输入层，将输入的三个特征合并成一个列向量，用$a^{[0]}$表示他们。即：

\[a^{[0]} = x = \left[ \begin{matrix} x_1 \\ x_2 \\ x_3 \end{matrix} \right] = \left[ \begin{matrix} a^{[0]}_1 \\ a^{[0]}_2 \\ a^{[0]}_3 \end{matrix} \right]\]

$w$的维度取决于从上一层引入的特征数和本层需要产生的特征数。对于隐藏层每一个神经元，都从输入层引入了3个特征，所以每一个神经元都有3个参数 ($w_{n1}, w_{n2}, w_{n3}$)，可以合并成一个 3x1 的矩阵$w_n$。隐藏层共包含4个神经元，就有4个 3x1 的参数 ($w_1, w_2, w_3, w_4$)，将其合并为一个 3x4 大矩阵$W$：

\[W = \left[ \begin{matrix} w_{11} & w_{21} & w_{31} & w_{41}\\ w_{12} & w_{22} & w_{32} & w_{42}\\ w_{13} & w_{23} & w_{33} & w_{43} \end{matrix} \right]\]

每一个神经元对应一个参数$b$，同样将其合并为矩阵：

\[b = \left[ \begin{matrix} b_1 \\ b_2 \\ b_3 \\ b_4 \end{matrix} \right]\]

前向传播

对于每一个神经元，计算过程如下图所示：

回到两层神经网络，逐个计算每个神经元。

首先使用线性方程计算第一层即隐藏层各节点的$z^{[1]}$，将结果代入激活函数计算$\alpha^{[1]}$，并将$\alpha^{[1]}$作为第二层的输入值传入神经网络的第二层。然后用另一组线性方程和激活函数计算$z^{[2]}$和$\alpha^{[2]}$，将$\alpha^{[2]}$作为输出。这就是一个简单的神经网络前向传播的计算过程。

公式如下：

\[(a^{[0]}, \theta^{[1]}) \Rightarrow z^{[1]} = W^{[1]T}x + b^{[1]}\Rightarrow \alpha^{[1]} = \sigma(z^{[1]})\] \[(\sigma, \theta^{[2]}) \Rightarrow z^{[2]} = W^{[2]T}\sigma^{[2]} + b^{[2]}\Rightarrow \alpha^{[2]} = \sigma(z^{[2]})\]

其中，各数据维度如下：

Data	Dimension
$a^{[0]}$	(3, 1)
$W^{[1]}$	(3, 4)
$b^{[1]}$	(4, 1)
$z^{[1]}, a^{[1]}, \sigma(z^{[1]})$	(4, 1)
$W^{[2]}$	(4, 1)
$b^{[2]}$	(1, 1)
$z^{[2]}, a^{[2]}, \sigma(z^{[2]})$	(1, 1)

以上公式就完成了对一个样本的数据计算，最后给出的结果即为对该样本的预测结果。对于所有样本，同样可以通过向量化简化其运算。

公式整理

设数据中共有$m$个样本，每个样本有$n^{[0]}$个特征。每一个样本的特征可以合并为一个 $(n^{[0]}, 1)$ 的列向量。将所有样本对应的列向量转置然后堆叠在一起，即得到了一个维度为$ (m, n^{[0]})$ 的矩阵，X。

建立一个 $l$ 层的神经网络。每一层的特征数（神经元个数）用$n$表示，即为 $(n^{[1]}, n^{[2]}, …, n^{[l]})$。

相对应的，公式也应该变为如下形式以和其维度相匹配：

\[(X, \theta^{[1]}) \Rightarrow z^{[1]} = XW^{[1]} + b^{[1]T}\Rightarrow \alpha^{[1]} = \sigma(z^{[1]})\] \[(\sigma(z^{[1]}, \theta^{[2]}) \Rightarrow z^{[2]} = \sigma^{[2]}W^{[2]} + b^{[2]T}\Rightarrow \alpha^{[2]} = \sigma(z^{[2]})\] \[\vdots\] \[(\sigma(z^{[l-1]}, \theta^{[l]}) \Rightarrow z^{[l]} = \sigma^{[l]}W^{[l]} + b^{[l]T}\Rightarrow \alpha^{[l]} = \sigma(z^{[l]})\]

数据维度如下：

Data	Dimension
$X$	$(m, n^{[0]})$
$W^{[1]}$	$(n^{[0]}, n^{[1]})$
$b^{[1]}$	$(n^{[1]}, 1)$
$z^{[1]}, a^{[1]}, \sigma(z^{[1]})$	$(m, n^{[1]})$
$W^{[2]}$	$(n^{[1]}, n^{[2]})$
$b^{[2]}$	$(n^{[2]}, 1)$
$z^{[2]}, a^{[2]}, \sigma(z^{[2]})$	$(m, n^{[2]})$
$\vdots$	$\vdots$
$W^{[l]}$	$(n^{[l-1]}, n^{[l]})$
$b^{[l]}$	$(n^{[l]}, 1)$
$z^{[l]}, a^{[l]}, \sigma(z^{[l]})$	$(m, n^{[l]})$

激活函数

在神经网络中，激活函数决定来自给定输入集的节点的输出，其中非线性激活函数允许网络模拟复杂的非线性行为。同时，激活函数需要是（几乎完全）可微分的，才可以通过梯度下降对神经网络进行优化。此外，复杂的激活函数可能会产生梯度消失或梯度爆炸等问题。

使用一个神经网络时，需要决定使用哪种激活函数用在隐藏层上，哪种用在输出节点上。前面用到的sigmoid函数在某些情况下效果很好，但在某些情况下会出问题，这时可以使用其他激活函数。

常见的激活函数包括Sigmoid、ReLU、Linear等，还有一些特殊的激活函数如Softmax。

Sigmoid

公式：

\[\alpha = \sigma(z) = \frac{1}{1 + e^{-z}}\]

图像：

Sigmoid函数可以将实际的输出值“挤压“到0到1的范围内，适合输出为概率的情况。但由于其存在一些问题，现在已经很少有人在构建神经网络的过程中使用Sigmoid函数了。

存在的问题：

Sigmoid函数饱和使梯度消失。当Sigmoid值接近0和1时，其导数会接近0，那么求得的梯度也会接近0，这会导致算法在反向传播的过程中没有信号传回上一层，即梯度消失。
Sigmoid函数的输出不是零中心的。Sigmoid函数产生的结果总是正数且平均值为0.5而不是0，这会使神经网络收敛的速度更慢。因为下一层神经网络的输入值不是零中心，就更容易产生饱和，导致梯度消失。

Tanh

公式：

\[\alpha = 2\sigma(2z) - 1 = \frac{1 - e^{-z}}{1 + e^{-z}}\]

图像：

Tanh是将Sigmoid函数的范围扩展到了 (-1, 1)，这就解决了SIgmoid函数输出不是零中心的问题。但仍然存在函数饱和的问题。结果表明，如果在隐藏层上使用tanh，结果总是优于sigmoid函数。但是在输出层上，如果需要处理二分类问题，就需要y的值处于0和1之间而不是-1和1之间。此时需要使用sigmoid函数。

为了防止饱和，现在主流的做法会在激活函数前多做一步batch normalization，尽可能保证每一层网络的输入值具有均值较小，零中心的分布。

ReLU

公式：

\[\alpha = max(0, z)\]

图像：

修正线性单元（Rectified linear unit，ReLU）函数是神经网络中最常用的激活函数。ReLU函数模仿了生物神经元的特性，即只有在输入超过阈值时才激活神经元。并且在输入为正时，导数不为0，从而允许基于梯度下降的优化。因为无论是其函数还是导数都不包含复杂的数学运算，所以使用ReLU函数也极大的减少了计算时间。

然而，当输入值为负时，ReLU函数的梯度为0，从而其权重无法得到更新，并且在此后的训练过程中该神经元会一直保持沉默，即神经元死亡。但是，有足够的隐藏层使ReLU函数的输入值大于0，所以对于大多数训练数据来说学习过程仍然可以很快。

如果在隐藏层上不确定使用哪个激活函数，那么通常会使用ReLU函数。

还有另一个版本的ReLU函数被称为Leaky ReLU。当z是负值时，其函数值不是0，而是轻微的倾斜。

图像：

由于其在负半区梯度不为0，所以不会产生ReLU函数在负半区神经元死亡的问题。这个函数通常比ReLU函数效果要好，但并不常用。

Softmax

公式：

\[S_i = \frac{e^{z_i}}{\sum\limits_{j = 1}^n e^{z_j}}\]

示意图如下：

Softmax函数是Logistic回归模型在多分类问题上的推广，适用于多分类且不同类别之间互斥的问题。当类别数 k = 2 时，Softmax函数退化为Logistic回归。Softmax函数可以将多个神经元的输出映射到 (0, 1) 区间，可以看作当前输出是其属于各分类的概率，从而解决多分类的问题。

对Softmax函数求导：

当 $i = j$ 时：

\[\frac{\partial S_i}{\partial z_j} = \frac{\partial \frac{e^{z_i}}{\sum\limits_{k = 1}^{n} e^{z_k}}}{\partial z_j} = \frac{e^{z_i}\sum\limits_{k = 1}^{n} e^{z_k} - e^{z_i}e^{z_j}}{[\sum\limits_{k = 1}^{n} e^{z_k}]^2} = \frac{e^{z_i}}{\sum\limits_{k = 1}^{n} e^{z_k}}\frac{\sum\limits_{k = 1}^{n} e^{z_k} - e^{z_j}}{\sum\limits_{k = 1}^{n} e^{z_k}} = S_i(1 - S_j)\]

当 $i \neq j$ 时：

\[\frac{\partial S_i}{\partial z_j} = \frac{\partial \frac{e^{z_i}}{\sum\limits_{k = 1}^{n} e^{z_k}}}{\partial z_j} = \frac{0 - e^{z_i}e^{z_j}}{[\sum\limits_{k = 1}^{n} e^{z_k}]^2} = -\frac{e^{z_i}}{\sum\limits_{k = 1}^{n} e^{z_k}}\frac{e^{z_j}}{\sum\limits_{k = 1}^{n} e^{z_k}} = -S_iS_j\]

即：

\[\frac{\partial S_i}{\partial z_j} = \begin{cases} S_i(1 - S_j) & \text{if}\ i = j \\ -S_iS_j & \text{if}\ i \neq j \end{cases}\]

结果可用雅可比矩阵表示：

\[\frac{\partial S_i}{\partial z_j} = \left[ \begin{matrix} \frac{\partial S_1}{\partial z_1} & \frac{\partial S_1}{\partial z_2} & \cdots & \frac{\partial S_1}{\partial z_n}\\ \frac{\partial S_2}{\partial z_1} & \frac{\partial S_2}{\partial z_2} & \cdots & \frac{\partial S_2}{\partial z_n}\\ \vdots & \vdots & \ddots & \vdots \\ \frac{\partial S_n}{\partial z_1} & \frac{\partial S_n}{\partial z_2} & \cdots & \frac{\partial S_n}{\partial z_n}\\ \end{matrix} \right] = \left[ \begin{matrix} S_1(1 - S_1) & -S_1S_2 & \cdots & -S_1S_n\\ -S_2S_1 & S_2(1 - S_2) & \cdots & -S_2S_n\\ \vdots & \vdots & \ddots & \vdots \\ -S_nS_1 & -S_nS_2 & \cdots & S_n(1 - S_n)\\ \end{matrix} \right]\]

代价函数

代价函数是神经网络模型优化时的目标，通过最小化代价函数来优化模型。对于不同的任务类型，神经网络模型需要使用不同的代价函数。

常见的有代价函数有均方差代价函数、对数损失函数、交叉熵等。

均方差代价函数

公式：

\[J_{\theta} = \frac{1}{2m}\sum\limits_{i = 1}^{m}[h_{\theta}(x^{(i)}) - y^{(i)}]^2\]

式中，$h_{\theta}(x^{(i)})$表示对第$i$个样本的预测值，$y^{(i)}$表示该样本对应的真实值。$\frac{1}{2}$的作用是简化后面的求导运算。

均方差代价函数适用于回归模型。当预测值越接近真实值，代价函数会越接近0。

计算梯度如下：

\[\frac{\partial}{\partial\theta_n}J_{\theta} = \sum\limits_{i = 1}^{m}[(h_{\theta}(x^{(i)}) - y^{(i)})x^{(i)}_n]\]

式中，当 $n$ 取值为 (1, n) 时，$\theta_n$对应为$w_n$，$x^{(i)}_n$对应该样本的第 $n$ 个特征。当 $n$ 取值为0时，$\theta_n$即 $\theta_0$ 对应 $b$，取$x^{(i)}_0 = 1$。

对数损失函数

公式：

\[Loss(y, P(y | x)) = -logP(y | x)\]

其中：

\[P(y | x) = \begin{cases} h_\theta(x) & \text{if}\ y = 1 \\ 1 - h_\theta(x) & \text{if}\ y = 0 \end{cases}\]

所以，$Loss$ 函数可简化为：

\[Loss(y, P(y | x)) = -y * log(h_\theta(x)) - (1 - y) * log(1 - h_\theta(x))\]

即取 y 和 (1 - y) 表示两种情况，y = 1 时，(1 - y) 为0，y = 0 时，(1 - y) 为1。

对应的代价函数为：

\[J(\theta) = -\frac{1}{m}\sum\limits_{i = 1}^{m}Loss = -\frac{1}{m}\sum\limits_{i = 1}^{m}[y^{(i)} * log(h_\theta(x^{(i)})) + (1 - y^{(i)}) * log(1 - h_\theta(x^{(i)}))]\]

当 y = 1且 h(x) = 1 时误差为零，且当 h(x) < 1 时Loss随h的减小而增大；当 y = 0 且 h(x) = 0 时误差为零，且当 h(x) > 1 时Loss随h增大而增大。

对数损失函数适用于二分类问题，即逻辑回归。其本身是由统计学中最大似然估计得出。在其激活函数使用Sigmoid函数的情况下，计算梯度如下：

\[\frac{\partial}{\partial\theta_n}J_{\theta} = \frac{1}{m}\sum\limits_{i = 1}^{m}[(h_{\theta}(x^{(i)}) - y^{(i)})x^{(i)}_n]\]

此式和均方差代价函数梯度表达式相同，但其中的$h_{\theta}(x^{(i)})$不同，所以两个代价函数不同。

交叉熵

概率:

\[P(x | \theta)\]

其含义为在已知 $\theta$ 的条件下，最后的结果为 $x$ 的可能性。

最大似然估计：

\[L(\theta | x)\]

其含义为在已知结果为 $x$ 的条件下，取环境变量为 $\theta$ 时结果为 $x$ 的可能性。即：

\[L(\theta | x) = P(x | \theta)\]

对于多个可能的结果，最大似然估计的表达式如下：

\[L(\theta) = P(x_1, x_2, ..., x_m | \theta) = p(x_1 | \theta)p(x_2 | \theta)...p(x_m | \theta) = \prod\limits_{i = 1}^{m}P(x_i | \theta)\]

根据定义可知，概率和最大似然估计的区别为：$L$ 是关于 $\theta$ 的函数，$P$ 是关于 $x$ 的函数。在神经网络中，我们需要根据已知事件来找出产生这种结果的最有可能的条件，目的是根据这个最有可能的条件去推测未知事件。最大似然函数在现有数据的条件下，通过调整环境变量 $\theta$ 来获取最大可能性，最后产生的结果即可用于对未知数据的预测。

为便于计算，用 $log$ 函数将最大似然估计中的累乘转化为求和：

\[log(L(\theta)) = log(\prod\limits_{i = 1}^{m}P(x_i | \theta)) = \sum\limits_{i = 1}^{m}log(P(x_i | \theta))\]

观察 $log$ 函数图像可知，当 $L(\theta) = 1$ 时，$log(L(\theta)) = 0$；当 $L(\theta) \rightarrow 0 $ 时，$log(L(\theta)) \rightarrow -\infty$。

我们需要优化 $\theta$ 使得 $L(\theta)$ 尽可能接近1。即最大化似然。

另一种解释最大似然估计的观点是将它看作最小化经验分布（即真实情况下数据分布，$p_{data}$）和模型分布（即预测的分布，$p_{model}$）之间的差异，两者之间的差异程度可以通过KL散度度量。定义如下：

\[D_{KL}(p_{data}||p_{model}) = \frac{1}{m}\sum\limits_{i = 1}^{m} \{ p_{data}(x^{(i)}) [log(p_{data}(x^{(i)})) - log(p_{model}(x^{(i)}))] \}\]

$p_{data}$ 表示真实情况下的数据分布概论，与模型无关。这意味着当训练模型最小化KL散度时，我们只需要最小化：

\[-\frac{1}{m}\sum\limits_{i = 1}^{m} [p_{data}(x^{(i)}) log(p_{model}(x^{(i)}))]\]

所以定义损失函数如下：

\[Loss(\theta) = -\frac{1}{m}\sum\limits_{i = 1}^{m}[y^{(i)}log(P(x^{(i)} | \theta))]\]

最小化KL散度其实就是在最小化分布之间的交叉熵。

实际计算时，为简化计算过程，取：

\[P(x^{(i)} | \theta) = \begin{cases} h_\theta(x_j) & \text{if}\ y_k = 1 \\ 1 - h_\theta(x_j) & \text{if}\ y_k = 0 \end{cases}\]

则：

\[Loss(\theta) = -\frac{1}{m}\sum\limits_{i = 1}^{m}[y^{(i)}log(P(x^{(i)} | \theta))] = -\frac{1}{m}\sum\limits_{i = 1}^{m}\sum\limits_{k = 1}^{n}[y^{(i)}_klog(h_{\theta}(x_k^{(i)})]\]

可以看出，逻辑回归中的对数损失函数是交叉熵取 $n = 2$ 即只有两个分类时的特例。

反向传播

反向传播过程也和逻辑回归过程很相似，需要通过代价函数和梯度下降来优化每一层的参数。不同的是，由于神经网络每一层相对独立，且层数较多，不能直接用代价函数对所有参数进行求导。所以需要使用高等数学中的链式法则，对每一层分别求导。

使用在前向传播过程中构建的神经网络：

设数据中共有$m$个样本，每个样本有$n^{[0]}$个特征。建立一个 $l$ 层的神经网络。每一层的特征数（神经元个数）用$n$表示，即为 $(n^{[1]}, n^{[2]}, …, n^{[l]})$。

前向传播过程如下：

以 $X$ 作为输入数据，$\sigma(z^{[l]})$即为最后的预测值。

使用代价函数计算预测值和真实值之间的差距，代价函数表示为 $J(\theta)$。

则用链式法则计算反向传播过程如下：

计算梯度：

\[\frac{\partial J(\theta)}{\partial z^{[l]}} = \frac{\partial J(\theta)}{\partial \sigma(z^{[l]})} \frac{\partial \sigma(z^{[l]})}{\partial z^{[l]}}\] \[\frac{\partial J(\theta)}{\partial \theta^{[l]}} = \frac{\partial J(\theta)}{\partial z^{[l]}} \frac{\partial z^{[l]}}{\partial \theta^{[l]}}\] \[\frac{\partial J(\theta)}{\partial z^{[l - 1]}} = \frac{\partial J(\theta)}{\partial z^{[l]}} \frac{\partial z^{[l]}}{\partial \sigma(z^{[l - 1]})} \frac{\partial \sigma(z^{[l - 1]})}{\partial z^{[l - 1]}}\] \[\frac{\partial J(\theta)}{\partial \theta^{[l - 1]}} = \frac{\partial J(\theta)}{\partial z^{[l - 1]}} \frac{\partial z^{[l - 1]}}{\partial \theta^{[l]}}\] \[\vdots\] \[\frac{\partial J(\theta)}{\partial z^{[1]}} = \frac{\partial J(\theta)}{\partial z^{[2]}} \frac{\partial z^{[2]}}{\partial \sigma(z^{[1]})} \frac{\partial \sigma(z^{[1]})}{\partial z^{[1]}}\] \[\frac{\partial J(\theta)}{\partial \theta^{[1]}} = \frac{\partial J(\theta)}{\partial z^{[1]}} \frac{\partial z^{[1]}}{\partial \theta^{[1]}}\]

完成全部梯度的计算以后更新参数：

\[\theta^{[l]} := \theta^{[l]} - \alpha \frac{\partial J(\theta)}{\partial \theta^{[l]}}\] \[\theta^{[l - 1]} := \theta^{[l - 1]} - \alpha \frac{\partial J(\theta)}{\partial \theta^{[l - 1]}}\] \[\vdots\] \[\theta^{[1]} := \theta^{[1]} - \alpha \frac{\partial J(\theta)}{\partial \theta^{[1]}}\]

其中，所有数据的导数的维度和数据自身的维度相同。

Machine Learning: 逻辑回归

2019-03-15T11:34:37+00:00

以乳腺癌分类预测为例介绍机器学习中的逻辑回归。

逻辑回归（Logistic Regression）

参考：

Machine Learning小结(1)：线性回归、逻辑回归和神经网络

逻辑回归（Logistic Regression）（一）

机器学习之对数几率回归(Logistic Regression)

吴恩达机器学习

深度学习工程师_01.神经网络和深度学习

卷积神经网络的Python实现

sklearn.datasets.load_breast_cancer

环境：

操作系统：Ubuntu 18.04

编程语言：Python 3.6.7

第三方库：numpy\matplotlib\scikit-learn

import imp
import numpy as np					# 科学计算
import matplotlib.pylab as plt				# 绘图
from sklearn import datasets				# 数据集
from sklearn.model_selection import train_test_split	# sklearn中的数据分割工具

定义

是一种用来解决分类问题的机器学习方法，用于估计某种事物的可能性。逻辑回归是一种广义线性回归，因此与线性回归分析有很多相同之处。他们的模型形式基本相同，都具有 wx + b ，其中w和b是待求参数。其区别在于他们的因变量不同，线性回归直接将 wx + b 作为因变量，即 h = wx + b ，而逻辑回归则通过逻辑函数将 wx + b 映射为一个非线性的特征p，表示某一分类的可能性，并将其作为因变量。逻辑回归的公式表示为：

\[h_\theta(x) = P(y = 1|x; \theta)\]

即在给定自变量及其参数的情况下，y = 1的概率。

如果采用常函数作为逻辑函数，则该模型即为线性回归模型。在机器学习中，将这个逻辑函数称为激活函数。常用的激活函数有sigmoid、Tanh、ReLU、softmax等。

数据处理

采用sklearn乳腺癌数据集：

cancer = datasets.load_breast_cancer()
data_X = cancer.data
data_y = cancer.target

乳腺癌数据集一共包括30个特征，target是诊断结果，即是否患有乳腺癌。将数据分为训练及和测试集，选择第1个特征和第27个特征作为自变量，target作为因变量。

x_train, x_test, y_train, y_test = train_test_split(data_X, data_y, test_size = 0.05)
x1 = x_train[:, 0]
x2 = x_train[:, 27]
y = y_train

前向传播

调用matplotlib对所选数据进行绘图，所有 y = 0 的点将其表为绿色，y = 1 的点将其标为红色。

for i in range(x.shape[0]):
    if y[i] == 0:
        plt.scatter(x1[i], x2[i], color = 'green')
    else:
        plt.scatter(x1[i], x2[i], color = 'red')

如果要对这组数据进行分类，就需要有一个这样的函数：值在0和1之间，当该函数大于某一个值时，判断其为1，小于时判断其为0。逻辑回归模型的假设是：

\[h(x) = g(\theta^Tx)\]

其中，$\theta^Tx$表示其决策边界，即两类数据的分隔边界。g代表逻辑函数。对于二分类问题，这里使用一个常见的逻辑函数：Sigmoid Function，公式为：

\[g(z) = \frac{1}{1 + e^{-z}}\]

python代码实现：

def sigmoid(z):
    return 1 / (1 + np.exp(-z))

该函数的图像为:

h(x) 的作用是，对于给定的输入变量，根据选择的参数计算 y = 1 的可能性。当 z > 0，g(z) > 0.5，预测 y = 1；当 z < 0，g(z) < 0.5，预测 y = 0。

由于我们采用了两个自变量x1和x2，所以逻辑函数为：

\[h(x) = g(\theta^Tx) = g(w^Tx + b) = g(w_1x_1 + w_2x_2 + b)\]

为简化计算量，可以将x1x2和w1w2分别组合成矩阵，然后通过numpy进行运算。

\[z(x) = w^Tx + b = \left[ \begin{matrix} x_{11} & x_{21}\\ x_{12} & x_{22}\\ \vdots & \vdots\\ x_{1m} & x_{2m} \end{matrix} \right] = \left[ \begin{matrix} w_1\\ w_2\\ \end{matrix} \right] + b\] \[h(x) = g(\theta^Tx) = sigmoid(z)\]

训练集共包含540个样本，将x1和x2合并成一个 (540, 2) 的矩阵，并使用随机数初始化参数w和b，然后计算h，并取m作为样本个数：

x = np.column_stack((x1, x2))
w = np.random.rand(2, 1)
b = np.random.rand(1, 1)
z = np.dot(x, w) + b
h = sigmoid(z)
m = x.shape[0]

反向传播

反向传播过程需要通过损失函数和代价函数来优化参数。对于线性回归模型，我们使用最小二乘法定义了损失函数。理论上来说，我们也可以用它定义逻辑回归模型的损失函数，但将sigmoid函数带入代价函数时，对w和J作图，将得到一个非凸函数。

这意味着我们的代价函数有许多局部最小值，这将影响梯度下降算法寻找全局最小值。

线性回归的代价函数为：

\[J(\theta) = \frac{1}{2m}\sum\limits_{i = 1}^{m}[h_\theta(x^i), y^i]^2\]

重新定义逻辑回归的代价函数：

\[J(\theta) = \frac{1}{m}\sum\limits_{i = 1}^{m}Loss(h_\theta(x^i), y^i)\]

其中：

\[Loss(h_\theta(x^i), y^i) = \begin{cases} log(h_\theta(x)) & \text{if}\ y = 1 \\ log(1 - h_\theta(x)) & \text{if}\ y = 0 \end{cases}\]

h与Loss( h(x), y ) 的关系如下图：

这样构建的 Loss( h(x), y ) 函数的特点是：当 y = 1且 h(x) = 1 时误差为零，且当 h(x) < 1 时Loss随h的减小而增大；当 y = 0 且 h(x) = 0 时误差为零，且当 h(x) > 1 时Loss随h增大而增大。

上式可以简化为：

\[Loss(h_\theta(x^i), y^i) = -y * log(h_\theta(x)) - (1 - y) * log(1 - h_\theta(x))\]

即取 y 和 (1 - y) 表示两种情况，y = 1 时，(1 - y) 为0，y = 0 时，(1 - y) 为1。

python代码实现：

Loss = - y*(np.log(h)) - (1-y)*(np.log(1-h))
J = 1/m * np.sum(Loss)

得到代价函数以后，使用梯度下降算法来优化参数。算法为：

repeat until convergence {

\[\theta := \theta - \alpha\frac{\partial}{\partial \theta}{J(\theta)}\]

}

求导后得：

repeat until convergence {

\[\theta := \theta - \alpha\frac{1}{m}\sum\limits_{i = 1}^{m}\{[h_\theta(x^i) - y^i]x^i\}\]

}

推导过程：

这个结果看起来是和线性回归梯度下降的结果是一样的，但由于其中假设的定义（h）发生了变化，所以逻辑回归的梯度下降跟线性回归的梯度下降完全不同。

逻辑回归的梯度下降过程为：

repeat until convergence {

\[w := w - \alpha\frac{1}{m}\sum\limits_{i = 1}^{m}\{[h(x^i) - y^i]x^i\}\] \[b := b - \alpha\frac{1}{m}\sum\limits_{i = 1}^{m}[h(x^i) - y^i]\]

}

注意：先完成计算然后同步更新所有参数。

python代码为：

J0 = 0
J = 0
J_dv = abs(J0 - J)

alpha = 0.03

while(True):
    # Hypothesis
    z = np.dot(x, w) + b
    h = sigmoid(z)
    
    # CostFunction
    J0 = J
    Loss = - y*(np.log(h)) - (1-y)*(np.log(1-h))
    J = 1/m * np.sum(Loss)
    J_dv = abs(J0 - J)
    
    # Derivative
    dw = 1/m * np.sum(((h - y) * x), axis = 0).reshape(-1, 1)
    db = 1/m * np.sum((h - y))

    # ParamUpdate
    w = w - alpha * dw
    b = b - alpha * db
    
    print(J)
    if J_dv <= 0.00000001:
        break

使用matplotlib绘图：

x1_t = np.linspace(7, 21.5, 100).reshape(100, 1)
x2_t = - (b + w[0] * x1_t) / w[1]

plt.plot(x1_t, x2_t, color = 'blue')
for i in range(x_train.shape[0]):
    if y[i] == 0:
        plt.scatter(x1[i], x2[i], color = 'green')
    else:
        plt.scatter(x1[i], x2[i], color = 'red')

结果基本符合训练集数据。

也基本符合测试集数据分布。

Machine Learning: 线性回归

2019-03-11T14:51:00+00:00

以波士顿房价预测为例介绍机器学习中的线性回归。

线性回归（Linear Regression）

参考：

Machine Learning小结(1)：线性回归、逻辑回归和神经网络

机器学习之线性回归(linear regression)

梯度下降（Gradient Descent）小结

吴恩达机器学习

深度学习工程师_01.神经网络和深度学习

卷积神经网络的Python实现

sklearn.datasets.load_boston

环境：

操作系统：Ubuntu 18.04

编程语言：Python 3.6.7

第三方库：numpy\matplotlib\scikit-learn

import imp
import numpy as np					# 科学计算
import matplotlib.pylab as plt				# 绘图
from sklearn import datasets				# 数据集
from sklearn.model_selection import train_test_split	# sklearn中的数据分割工具

定义

给定数据集D={(x1, y1), (x2, y2), … }，我们试图从此数据集中学习得到一个线性模型，这个模型尽可能准确地反应x(i)和y(i)的对应关系。这里的线性模型，就是属性(x)的线性组合的函数，可表示为：

\[f(x) = w_1x_1 + w_2x_2 + ... + w_nx_n + b\]

向量表示为：

\[f(x) = W^TX + b\]

其中，W是由(w1, w2, …, wn)组成的列向量，表示weight，即权重，b表示bias，即偏差。

在机器学习中，我们希望可以建立一个函数，使其尽可能符合现有的数据分布，这样我们就可以通过这个函数对未知的数据进行预测。线性回归需要解决的问题就是如何求得参数W和b，使函数获得最优解，即使其预测结果更接近真实值。

数据处理

首先我们需要获取数据集，然后根据数据集的分布确定我们的预测函数。

采用sklearn的波士顿房价数据集：

boston = datasets.load_boston()
data_X = boston.data
data_y = boston.target

波士顿房价数据集中data一共包含13个特征，target是最后的房价。通过以下代码可以查看其各项属性：

print(boston.DESCR)

.. _boston_dataset:

Boston house prices dataset
---------------------------

**Data Set Characteristics:**  

 :Number of Instances: 506 

 :Number of Attributes: 13 numeric/categorical predictive. Median Value (attribute 14) is usually the target.

 :Attribute Information (in order):
        - CRIM     per capita crime rate by town
        - ZN       proportion of residential land zoned for lots over 25,000 sq.ft.
        - INDUS    proportion of non-retail business acres per town
        - CHAS     Charles River dummy variable (= 1 if tract bounds river; 0 otherwise)
        - NOX      nitric oxides concentration (parts per 10 million)
        - RM       average number of rooms per dwelling
        - AGE      proportion of owner-occupied units built prior to 1940
        - DIS      weighted distances to five Boston employment centres
        - RAD      index of accessibility to radial highways
        - TAX      full-value property-tax rate per $10,000
        - PTRATIO  pupil-teacher ratio by town
        - B        1000(Bk - 0.63)^2 where Bk is the proportion of blacks by town
        - LSTAT    % lower status of the population
        - MEDV     Median value of owner-occupied homes in $1000's

 :Missing Attribute Values: None

 :Creator: Harrison, D. and Rubinfeld, D.L.

This is a copy of UCI ML housing dataset.
https://archive.ics.uci.edu/ml/machine-learning-databases/housing/


This dataset was taken from the StatLib library which is maintained at Carnegie Mellon University.

The Boston house-price data of Harrison, D. and Rubinfeld, D.L. 'Hedonic
prices and the demand for clean air', J. Environ. Economics & Management,
vol.5, 81-102, 1978.   Used in Belsley, Kuh & Welsch, 'Regression diagnostics
...', Wiley, 1980.   N.B. Various transformations are used in the table on
pages 244-261 of the latter.

The Boston house-price data has been used in many machine learning papers that address regression
problems.   
  
.. topic:: References

   - Belsley, Kuh & Welsch, 'Regression diagnostics: Identifying Influential Data and Sources of Collinearity', Wiley, 1980. 244-261.
   - Quinlan,R. (1993). Combining Instance-Based and Model-Based Learning. In Proceedings on the Tenth International Conference of Machine Learning, 236-243, University of Massachusetts, Amherst. Morgan Kaufmann.

为了便于测试模型的准确性，训练出准确性最好，泛化程度最高的模型，我们需要将模型分割成训练集、验证集和测试集。方便起见，在此我们仅将其分为训练集和测试集。使用sklearn的split工具分割数据：

x_train, x_test, y_train, y_test = train_test_split(data_X, data_y, test_size = 0.05)

train_test_split将数据集随机分为了训练集和测试集两部分，分别占原数据集的95%和5%。后面将使用这两个数据集训练模型并对其进行检测。

选择数据集中第6个特征作为自变量，target作为因变量。根据上面的属性可以看出，该特征为average number of rooms per dwelling，即住所平均房间数。

x = x_train[:, 5]
y = y_train

前向传播

调用matplotlib对所选数据进行绘图：

plt.scatter(x, y)

可以看出，数据近似为一个一次函数。因此我们使用以下函数预测数据： $h(x) = wx + b$ 如果数据分布近似二次函数或其他类型函数，就需要改变预测函数的形式，使其符合数据分布规律。此函数中，h(x)即为该函数预测的房价，x为房间数，w和b是该函数的参数。采用随机值为w和b赋值，可产生第一个预测的函数：

x = x.reshape（-1， 1）
w = np.random.rand(1, 1)
b = np.random.rand(1, 1)
h = np.dot(x, w) + b

x，w和b都是矩阵格式的数据。b和h的维度不一致但也可以进行运算，这是使用了numpy中的广播机制。h即为使用w和b作为参数预测的房价。对其进行绘图：

plt.scatter(x, y)
plt.plot(x, h, color = 'red')

可以看出，此时预测的函数偏差还很大，不能作为最后的结果。

反向传播

反向传播过程需要通过数据集中的target来优化现在的预测函数，使它的预测值尽可能接近真实值。

定义每一个样本的预测结果与真实值之间的偏差的表达式为损失函数（Loss Function），所有损失函数的和为代价函数（Cost Function）。当Cost Function接近最小值，我们就可以认为函数预测的结果已经接近真实值。在线性回归中，使用最小二乘法来定义其损失函数：

\[Loss = [h(x^i) - y^i]^2\]

Cost Function是所有Loss的和：

\[J = \frac{1}{2m}\sum\limits_{i = 1}^{m} Loss = \frac{1}{2m}\sum\limits_{i = 1}^{m} [h(x^i) - y^i]^2\]

式中m是样本数量。当J接近0的时候，h(x) 近似等于 y，可以认为该函数的预测值接近真实值。1/2m的作用是简化后面的求导运算。

m = x.shape[0]
J = 1/(2*m) * np.sum(np.power((h - y), 2))

完成以上定义以后，我们就可以通过优化w和b来使J接近0，即可获得最佳的预测函数。

梯度下降（Gradient Descent）

结合预测函数h和代价函数J，我们可以得到以下表达式：

\[J = \frac{1}{2m}\sum\limits_{i = 1}^{m} [h(x^i) - y^i]^2 = \frac{1}{2m}\sum\limits_{i = 1}^{m} [wx^i + b - y^i]^2\]

先简化上式，假设b = 0，则该表达式就变成了：

\[J = \frac{1}{2m}\sum\limits_{i = 1}^{m} [wx^i - y^i]^2\]

可以看出，现在J的大小只受w的影响。设w为自变量J为因变量，可画出以下图像：

w = np.arange(-2, 10, 0.1).reshape(1, -1)
h = np.dot(x, w)
J = 1/(2*m) * np.sum(np.power((h - y), 2), axis = 0)

plt.plot(w_t[0], J)
w = np.random.rand(1, 1)

任取一个w作为预测函数的初始参数，该参数对应着图像上的一个点。在该点用J对w求导，得到的结果就是梯度，从他的几何意义上来说，就是函数增长的方向。因此，要想使该点到达函数的局部/全局最优点，就需要让w减去这个梯度，使该点沿着函数值减小的方向前进。这就是梯度下降。公式为：

repeat until convergence {

\[\theta := \theta - \alpha\frac{\partial}{\partial \theta}{J(\theta)}\]

}

其中，θ是参数，对应预测函数中的w（和b），α是学习率。这个公式的含义就是让θ每次沿梯度下降的方向前进一点，直到函数收敛为止。学习率决定了每次前进的步长，如果学习率太小，训练过程会很慢；如果学习率过大，可能会使参数直接跨过最小值点，导致最后的结果无法收敛。另外，由于随着CostFunction趋近于最小值，函数的梯度逐渐减小，θ前进的步长也会逐渐减小，所以不需要随着训练过程改变α的值。

由于线性回归的CostFunction没有局部最优解，所以梯度下降的结果一定是全局最优解。

最小二乘法的代价函数的导数可以化简为如下形式：

\[\frac{\partial}{\partial w}{J(w)} = \frac{1}{m}\sum\limits_{i = 1}^{m}\{[h(x^i) - y^i]x^i\}\] \[\frac{\partial}{\partial b}{J(b)} = \frac{1}{m}\sum\limits_{i = 1}^{m}[h(x^i) - y^i]\]

所以梯度下降的过程为：

repeat until convergence {

\[w := w - \alpha\frac{1}{m}\sum\limits_{i = 1}^{m}\{[h(x^i) - y^i]x^i\}\] \[b := b - \alpha\frac{1}{m}\sum\limits_{i = 1}^{m}[h(x^i) - y^i]\]

由于更新参数会导致h发生变化，从而影响后面参数的更新过程，所以需要先完成计算然后同步更新所有参数。

J0 = 0
J = 0
J_dv = abs(J0 - J)

alpha = 0.03

while(True):
    # Hypothesis
    h = np.dot(x, w) + b
    
    # CostFunction
    J0 = J
    J = 1/(2*m) * np.sum(np.power((h - y), 2))
    J_dv = abs(J0 - J)
    
    # Derivative
    dw = 1/m * np.sum((h - y) * x)
    db = 1/m * np.sum(h - y)
    
    # ParamUpdate
    w = w - alpha * dw
    b = b - alpha * db
    
    if J_dv <= 0.00001:
        break

使用参数更新前后CostFunction的差值作为判断函数收敛的标志，当差值小于0.00001以后，可以认为函数的梯度为近似为0，函数收敛。

经过训练以后，预测函数已经有了比较好的效果，基本符合实际数据。

同时，在测试集上，该预测函数同样也基本符合数据分布。

《梭罗和他的湖》

2019-02-27T00:42:32+00:00

瓦尔登湖书评

《梭罗和他的湖》

何怀宏

十

…

他明确地说他希望世界上的人，越不相同越好。但他愿意每一个人都能谨慎地找出并坚持他自己的合适的方式，而不要简单地因袭和模仿他父亲的、或母亲的、或邻居的生活方式。他是一个天生的倡异议者，对每一个建议本能的反应是说“不”。而现在有什么人愿意做人中的黄蜂呢？人们更喜欢在互相恭维的泥淖中打滚。

他的善意和同情并不表现为顺从别人，他的坚定和明智也不要求别人的顺从。他要自己绝对自主，也要每一个人都绝对自主。可是一个人仍然可以在这种意义上成为一个和他一样的人：即成为一个与任何其他人（当然也包括梭罗）不同的人，成为一个可以说这一句话的人 —

我是我自己。

Shadowsocks（二）：客户端配置

2019-02-23T00:48:22+00:00

Ubuntu环境下使用Shadowsocks科学上网。使用Vultr服务器搭建SS服务端，并在本地配置网络代理。

注：本机操作系统为 Ubuntu 18.04，服务器的搭建请参考上一篇文章。

Shadowsocks（一）：基于Vultr搭建SS服务器

参考：

Linux安装配置Shadowsocks客户端及开机自动启动

用SwitchyOmega管理代理设置

Ubuntu终端使用Privoxy代理

1. Ubuntu环境下网络代理配置

Shadowsocks无GUI客户端配置

安装

安装Shadowsocks客户端需要python及其包管理工具pip，通过以下命令可以查看python和pip的版本：

$ python --version
$ pip --version

确定Python和pip都已经正确安装后，使用以下命令安装Shadowsocks客户端：

$ pip install shadowsocks

配置

创建Shadowsocks配置文件：

$ sudo touch /etc/shadowsocks/config.json

然后在该配置文件中添加服务器信息：

{

    "server":"my_server_ip",

    "server_port":my_server_port,

    "local_address": "127.0.0.1",

    "local_port":1080,

    "password":"my_password",

    "timeout":300,

    "method":"aes-256-cfb"
}

详细配置说明：

Name	说明
Server	服务器地址，填IP地址或域名
server_port	服务器开放端口
local_address	本地地址，127.0.0.1
local_port	本地端口，一般为1080
password	服务器密码
port_password	服务器端口 + 密码
timeout	超时重连
method	加密方式，默认aes-256-cfb
fast_open	TCP_FASTOPEN

测试启动

前端启动：sudo sslocal -c /etc/shadowsocks/config.json
后台启动：sudo sslocal -c /etc/shadowsocks/config.json -d start
后台停止：sudo sslocal -c /etc/shadowsocks/config.json -d stop
重启：sudo sslocal -c /etc/shadowsocks/config.json -d restart

开机启动

使用Systemd来实现shadowsocks开机自启。

$ sudo vim /etc/systemd/system/shadowsocks.service

在里面填写如下内容：

[Unit]
Description=Shadowsocks Client Service
After=network.target

[Service]
Type=simple
User=root
ExecStart=/usr/bin/sslocal -c /etc/shadowsocks/config.json 

[Install]
WantedBy=multi-user.target

配置生效：

systemctl enable /etc/systemd/system/shadowsocks.service

输入管理员密码后配置生效。

Shadowsocks_Qt5客户端配置

Qt5客户端使用snap应用商店的ss-qt。

安装

安装snap:

$ sudo apt update
$ sudo apt install snapd

安装ss-qt

sudo snap install ss-qt

代理配置

添加新的代理配置

保存后连接。

开机启动

在Startup Application中添加ss-qt即可。

2. Chrome浏览器网络代理配置

安装

使用SwitchyOmege配置Chrome浏览器的网络代理。首先需要在Chrome应用商店内安装SwitchyOmege

在线安装直接打开Chrome应用商店，添加至Chrome即可。（需要科学上网）

离线安装需要先下载SwithcyOmega的离线安装包，下载地址：

1.GitHub：https://github.com/FelisCatus/SwitchyOmega/releases/latest

2.在线下载：https://www.switchyomega.com/download/

下载得到SwitchyOmega_Chromium.crx这个离线安装文件后，在Chrome地址栏输入chrome://extensions打开扩展程序，之后打开开发者模式，将离线安装文件拖入到Chrome中即可进行安装。

配置代理

安装成功后，先删除其自带的情景模式，然后点击New profile新建配置文件。

名称为Vultr，类型选择Proxy Profile，点击创建。

代理协议选择SOCKS5，服务器和端口填写本地IP地址和端口号（local_address和local_port）。

配置完成后点击Apply changes保存配置。

再新建一个配置文件，名称为AutoSwitch，类型选择Switch Profile。

选择 Add a rule list 添加规则列表。

Rule List Format 选择Autoproxy。

Rule List URL 填写：https://raw.githubusercontent.com/gfwlist/gfwlist/master/gfwlist.txt

这个地址是GFWList的地址，基本包含了常用的所有被墙网址，并且一直在更新。

选择 Download Profile Now 下载Profile。

然后将 Switch Rules 中对应的配置文件改为Vultr，保存配置即可。

3. 终端网络配置

在Chrome上，是SwitchyOmega插件把HTTP和HTTPS流量转换成了socks协议的流量，才能使用socks代理。而Ubuntu终端是没有这样的协议转换的，所以没法直接使用sock5代理。这时候就需要一个协议转换器，例如Privoxy。

安装

$ sudo apt install privoxy

配置

修改privoxy配置文件/etc/privoxy/config，在文件末尾添加如下内容：

forward-socks5 / 127.0.0.1:1080 . # SOCKS5代理地址
listen-address 127.0.0.1:8080     # HTTP代理地址
forward 10.*.*.*/ .               # 内网地址不走代理
forward .abc.com/ .               # 指定域名不走代理

其中，第1行的 127.0.0.1:1080 是你在本地的SOCKS5代理地址，而第二行的 127.0.0.1:8080 则是SOCKS5转换成的 http 代理地址，最后两行指定了两个不走代理的地址。

配置好以后配置好之后重启Privoxy服务：

$ sudo /etc/init.d/privoxy restart

然后打开 /etc/profile，在最后添加以下两行：

export http_proxy="127.0.0.1:8080"
export https_proxy="127.0.0.1:8080"

即可在终端中科学上网。

测试

$ curl google.come

输入上述命令后显示Google首页的HTML代码即说明配置成功。

$ curl ip.gs

输入上述命令后显示当前IP地址。

由于执行ping指令使用ICMP传输协议，而SS代理是基于TCP或UDP协议，所以使用ping指令访问Google会超时。

Shadowsocks（一）：基于Vultr搭建SS服务器

2019-02-22T19:26:39+00:00

Ubuntu环境下使用Shadowsocks科学上网。使用Vultr服务器搭建SS服务端，并在本地配置网络代理。

注：本机操作系统为 Ubuntu 18.04，图中所示服务器仅为测试用例，将在结束后销毁。

Vultr服务器

Vultr是美国的一个VPS服务商，全球有15个数据中心，可以一键部署服务器。采用小时计费策略，可以在任何时间新建或者摧毁VPS服务器。价格低廉，最便宜的只要2.5一个月，支持支付宝及微信支付。

Vultr官网连接：Vultr The Infrastructure Cloud™

新用户注册

打开Vultr官网，在相应的位置填写邮箱和密码，然后创建账户即可。注册完会受到一封验证邮件，点击连接确认注册。

账户充值

Vultr的服务器价格从一个月2.5美元到640美元不等，可根据个人需求选择相应的服务器方案。对服务器需求较小的个人用户可选择一个月5美元的计费方案，其中包含了25GB的SSD，1个CPU，1024MB内存以及1000GB的流量。Vultr的收费方式实际上是按小时计费的，比如5美元一个月的服务器对应的收费标准为0.07美元一小时。记时从开通服务器开始，直到服务器被销毁为止。费用会自动从账户中扣除。在Billing页面可以查看当前余额并进行充值，支持的支付方式包括信用卡、Paypal、支付宝以及微信等，还可以用Gift Code充值。

创建服务器

充值成功后，进入Servers页面，点击右上角的加号创建服务器。

选择服务器配置，包括服务器位置，操作系统，机器配置以及附加服务等。

配置完成后点击Deploy Now完成创建。

配置服务器

服务器创建成功后，你就可以从Servers页面看到你的服务器。待其安装完成后，点击服务器可以查看其详细信息。其中包含你的服务器的IP地址，用户名和密码。

通过Linux终端连接VPS。

$ ssh -l 远程服务器用户名 服务器ip地址

随后输入密码即可连接远程服务器。

打开服务器终端以后开始配置和Shadowsocks，这里采用teddysun的一键安装脚本。逐行输入以下命令：

$ wget --no-check-certificate https://raw.githubusercontent.com/teddysun/shadowsocks_install/master/shadowsocks.sh
$ chmod +x shadowsocks.sh
$ ./shadowsocks.sh 2>&1 | tee shadowsocks.log

程序运行后将会出现如下所示界面：

为你的Shadowsocks服务器设置密码。

设置端口。

选择加密方式。

设置完成，按任意键开始配置Shadowsocks服务器。

配置成功，终端将显示本机的Shadowsocks配置信息，将其保存后可用于配置客户端的Shadowsocks连接。