人到中年，最高级的活法，不是聚会，也不是养生，而是享受一个人独处，缩小圈子，放下面子，远离烂人。

—— 《天道》

现在是2025年1月7日，人在ZH，正享受着一个人的独处。想起了以前写的博客，重新打开了我曾为你生日做的网站，所幸域名还没有过期，看着曾经写的一字一句，以及我们的相册，思绪万千。上一篇博客已是4年前了，我想我肯定是变了，不再是曾经那个我了，连基本的写博客的习惯也已经丢弃了这么久了。我到底都变了些什么，什么时候开始变的，为什么我会变化，我想趁这个孤独的夜晚思考清楚。

上一篇博客，还是在武汉的那个小出租屋里写的，也是最后一篇了。在北京的时候，生活重复单调，但充满了乐趣，因为有两个挚友在身边，我们一起上班出门，下班回来一起吐槽，让我现在印象最深的，还是下班路上，我们骑着车儿唱着歌，”那是一艘孤独的船，在苍茫的大海扬起了帆”，虽然是在8-9点左右下的班，但是我们丝毫没有感到疲惫，反而既兴奋又快乐，一路向那个出租屋里，也是我们的家里飞奔而去。下了班，痛痛快快的开两把游戏，输了互相骂，赢了互相吹，激情呐喊，尽情发泄，差不多10点多就准备洗澡睡觉了。周而复始，有时也会聊聊工作，探讨技术难题，分析写PPT的逻辑。到了周末，上午先开几把游戏，中午可能点外卖，也可能出去加餐，少有自己做饭的时候，下午可能逛逛商场，疯狂购物屯粮，晚上可能自己做点饭吃，再玩一玩健身环假装锻炼一下，或者聚在一起，边写代码边看电视剧，重温了甄嬛传、康熙王朝、大宋提刑官等经典巨作。也有可能去公司加加班，打打球。

可能会有人说我们沉迷游戏，但那几年却也是我技术长进最快、博客写的最多的几年，也是我掌握写PPT技巧的时间，也是我看书最多的几年；可能会有人说我们颓废不懂生活，可那几年却是我毕业以来生活最快乐的几年。无忧无虑，有钱有闲，也有好朋友在身边，工作也是钱多事少离家近，想做什么就可以做什么。回头想想，这不就是梦寐以求的生活吗？

那几年也是我最想念爱人的几年，因为异地，我只能每个月挑个周末赶回来，硬卧或是软卧，在车厢别人的鼾声中，我半梦半醒，整个人第二天都是精神恍惚，站都站不稳，也多了个外号“S老头”，虽说是玩笑，但确实是我挺不住了，眼睛都感觉睁不开了。现在想想，我现在身上的慢性病应该就是那时候落下的病根吧，两头奔波，纵欲过度，缺乏休息，终于把身体搞垮了。

从北京回来的那一年，原领导给了我很好的绩效，那也是我第一次年终奖过十万的高光时刻（可惜也是最后一次），他对我再三挽留，还请我吃了顿饭，说心里话，我很想留下来跟他好好干，因为我知道他是一个非常好的领导，我想我余生再不会碰到这样一个好领导了。但是没有办法，人生总是要做些取舍。回来的火车上，我看着窗外，我也在想：遥远的未来，我是否会后悔今天的选择呢？其实没有最好的答案，两条路都会有收获和遗憾，既然选择了，就脚踏实地走下去吧。

回到武汉的头一年，在那个出租屋里，我开始感受到武汉这座城市在就业上的巨大恶意。也许是在北京被善意对待了，才会没有防备，公司和房东都是连哄带骗，狠狠地坑了我一把，也让我现在都难以释怀，也让我碰到想回武汉的友人都会好好告诫他们，归来即巅峰，勿轻信他人，全都是谎言，全都是我吸取的教训。与此同时，我也感受到前所未有的孤独。身边没有可以交心的好友，就连游戏，也只能自己一个人寂寞的玩着，当我打出精彩操作的时候，我兴奋的想要大叫，却猛然一惊，身边已没有可以分享喜悦的人了，也没有人会来吹捧我的操作了。游戏开始变的没有意思了，我深爱多年的dota，渐渐让我感到厌倦。原来游戏真正的乐趣，是和志趣相投的朋友一起玩，一起分享胜利的喜悦，即便远程可以联机，但是关掉视频通话那一瞬间，环顾四周，只剩苍凉和寂寞。孤独感吞噬了我的多巴胺。

没有人会和我交流技术了，也没有人和我讨论投资、基金、股票了，也没有人和我讨论游戏了，也没有人会和我斟酌诗词了。我独自一人，坚持了几个月，看了E大所有的文章，反思我的操作；也看了工作中会用到的各种技术，整理成博客，直至2021.7月封笔。也许就是那之后，我就变了，我的生活也变了。

我步入了婚姻的殿堂，终于和我心心念念的爱人在一起了，我相信我们可以永结同心，白头偕老，因为我们有很深的感情基础和羁绊，我也愿意为她做各种事情。的确，只有我们两个人在一起的时候，日子过的平凡简单，但很幸福，我很喜欢过我们俩的小日子，我们一起去克服生活的万难，而这个过程中我们也能互相吹捧，给予情绪价值，形成良性循环。

但事情并没有想象中那么简单，我也终于知道了我内心深处渴望的生活，那也是我从小就想要的生活。就是逃离原生家庭，去组建一个我自己的家庭，享受仅属于我自己生活的自由。有时候，会很羡慕远离家乡的小两口们，他们在异乡努力拼搏，组建新的家庭，没有人打扰，想做什么就做什么，也不用去征求家里人的意见。也许有些事情会犯错，但那又何尝不是一种成长呢。当然这也是一把双刃剑，没有家人的帮助，在很多事情上终究会有所不便。但于我而言，我还是更想要摆脱家庭的琐事和控制吧。

市盈率：静态市盈率、动态市盈、TTM市盈（最近12个月市盈）。市盈率代表了市场对股票的悲观或乐观程度，也代表了股价的高估或低估程度。市盈率等于股价除以每股收益

市盈率的倒数就是当前的股票投资回报率，20倍的PE等于年5%的回报率，也就是20年回本。

其次，还可以与市场平均市盈率来做对比，市场平均市盈率因抽样范围的不同也会存在很大的差异

行业发展空间广阔与否，直接决定了一家公司到底是成长股还是价值股

PEG

PEG指标(市盈率相对盈利增长比率)是用公司的市盈率除以公司的盈利增长速度。 当时他在选股的时候就是选那些市盈率较低，同时它们的增长速度又是比较高的公司，这些公司有一个典型特点就是PEG会非常低。其计算公式是： PEG=PE/（企业年盈利增长率*100）

通常价值型股票的PEG都会小于1

利润增速高于ROE的是成长股，低于ROE的是价值股。最低ROE可以设置为15%，持续十年以上利润增速维持在15%的公司

@tf.function 使用

Reference: https://yaoyaowd.medium.com/tensorflow-2-0%E4%B8%8A%E6%89%8B6-%E8%A7%A3%E5%89%96tf-function%E7%9A%84%E4%BD%BF%E7%94%A8-b48cef249ca4

Tensorflow2.1代码像普通的Python代码一样简单。在Tensorflow 2.0中，会自动的对被@tf.function装饰的函数进行AutoGraph优化．

1
2
3
4
5

a = tf.constant([[10,10],[11.,1.]])
x = tf.constant([[1.,0.],[0.,1.]])
b = tf.Variable(12.)
y = tf.matmul(a, x) + b
print(y.numpy())

代码非常易读，但是也带来了执行效率低的问题，因为代码需要依赖Python的解释器来进行计算，无法对数据流以及计算图进行优化．

为了在代码可读性和代码速度之间保持平衡，Tensorflow 2.0引入了tf.function这一概念．

我们来粗浅的看一下被tf.function装饰的函数第一次执行时都做了什么：

1. 函数被执行并且被跟踪(tracing)．Eager execution处于关闭状态，所有的Tensorflow函数被当做tf.Operation进行图的创建．
2. AutoGraph被唤醒，去检测Python代码可以转为Tensorflow的逻辑，比如while > tf.while, for > tf.while, if > tf.cond, assert > tf.assert．
3. 通过以上两部，我们对函数进行建图，为了保证Python代码中每一行的执行顺序，tf.control_dependencies被自动加入到代码中．保证第i行执行完后我们会执行第i+1行．
4. 返回tf.Graph，根据函数名和输入参数，我们将这个graph存到一个cache中．
5. 对于任何一个该函数的调用，我们会重复利用cache中的计算图进行计算．

示例：

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

def f():
    a = tf.constant([[10,10],[11.,1.]])
    x = tf.constant([[1.,0.],[0.,1.]])
    b = tf.Variable(12.)
    y = tf.matmul(a, x) + b
    return y
print(f().numpy())
#执行结果
[[22. 22.]
 [23. 13.]]
@tf.function
def f():
    a = tf.constant([[10,10],[11.,1.]])
    x = tf.constant([[1.,0.],[0.,1.]])
    b = tf.Variable(12.)
    y = tf.matmul(a, x) + b
    print("PRINT: ", y)
    tf.print("TF-PRINT: ", y)
    return y
f()
#执行结果
PRINT:  Tensor("add:0", shape=(2, 2), dtype=float32)
ValueError: tf.function-decorated function tried to create variables on non-first call.

咦，为什么代码报错了？

tf.function可能会对一段Python函数进行多次执行来构图，在多次执行的过程中，同样的Variable被创建了多次，产生错误．

这其实也是一个很容易混乱的概念，在eager mode下一个Variable是一个Python object，所以会在执行范围外被销毁．但是在tf.function的装饰下，Variable变成了tf.Variable，是在Graph中持续存在的．

把一个在eager mode下正常执行的函数转换到Tensorflow图形式，需要一边思考着计算图一边构建程序．

解决方案：

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

# 将所有的内容写到一个class里，就好像Keras layer一样,所有的Variable都是class的内部参数(self._b)，将class的__call__()通过tf.function装饰．
class F():
    def __init__(self):
        self._b = None
    @tf.function
    def __call__(self):
        a = tf.constant([[10, 10], [11., 1.]])
        x = tf.constant([[1., 0.], [0., 1.]])
        if self._b is None:
            self._b = tf.Variable(12.)
        y = tf.matmul(a, x) + self._b
        print("PRINT: ", y)
        tf.print("TF-PRINT: ", y)
        return y
f = F()
f()

1
2
3
4
5
6
7
8
9
10
11

# 外部变量传入的形式
@tf.function
def f(b):
    a = tf.constant([[10,10],[11.,1.]])
    x = tf.constant([[1.,0.],[0.,1.]])
    y = tf.matmul(a, x) + b
    print("PRINT: ", y)
    tf.print("TF-PRINT: ", y)
    return y
b = tf.Variable(12.)
f(b)

Tf.keras.Metrics

Reference: https://blog.csdn.net/qq_39507748/article/details/105267168

• reset_states(),清除之前的计算结果，相当于复位重新开始计算
• result()，计算并且返回结果
• update_state()，将每一次更新的数据作为一组数据，这样在真正计算的时候会计算出每一组的结果，然后求多组结果的平均值。但并不会直接计算，计算还是在调用 result()时完成

1、tf.keras.metrics.Accuracy

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

m = tf.keras.metrics.Accuracy() 
_ = m.update_state([1, 2, 3, 4], [0, 2, 3, 4]) 
m.result().numpy() 
#输出：0.75
m.reset_states() 
'''
通俗来讲，sample_weight的作用就是用来指定
哪些数据用来计算结果，哪些不参与计算
'''
_ = m.update_state([1, 2, 3, 4], [0, 2, 3, 4], 
                    sample_weight=[1, 1, 0, 0]) 
m.result().numpy() 
#输出：0.5

2、tf.keras.metrics.BinaryAccuracy

1
2
3
4
5
6
7
8
9
10

'''
threshold用来指定一个阈值，如果数值超过这个阈值就认为是1，否则就是0
'''
tf.keras.metrics.BinaryAccuracy(
    name='binary_accuracy', dtype=None, threshold=0.5
)
m = tf.keras.metrics.BinaryAccuracy()
m.update_state([1, 1, 0, 0], [0.98, 1, 0, 0.6])
print('Final result: ', m.result().numpy())  # Final result: 0.75

3、tf.keras.metrics.BinaryCrossentropy

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

tf.keras.metrics.BinaryCrossentropy(
    name='binary_crossentropy', dtype=None, from_logits=False, label_smoothing=0
)
m = tf.keras.metrics.BinaryCrossentropy()
m.update_state([1., 0., 1., 0.], [1., 1., 1., 0.])
'''
# EPSILON = 1e-7, y = y_true, y` = y_pred, Y_MAX = 0.9999999
# y` = clip_ops.clip_by_value(output, EPSILON, 1. - EPSILON)
# y` = [Y_MAX, Y_MAX, Y_MAX, EPSILON]
# Metric = -(y log(y` + EPSILON) + (1 - y) log(1 - y` + EPSILON))
#        = [-log(Y_MAX + EPSILON), -log(1 - Y_MAX + EPSILON),
#           -log(Y_MAX + EPSILON), -log(1)]
#        = [(0 + 15.33) / 2, (0 + 0) / 2]
# Reduced metric = 7.665 / 2
'''
print('Final result: ', m.result().numpy())  # Final result: 3.833

4、tf.keras.metrics.CategoricalAccuracy

1
2
3
4
5

m = tf.keras.metrics.CategoricalAccuracy() 
_ = m.update_state([[0, 0, 1], [0, 1, 0]], [[0.1, 0.9, 0.8], 
                    [0.05, 0.95, 0]]) 
m.result().numpy() 
#输出：0.5

5、tf.keras.metrics.CategoricalCrossentropy

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

'''
from_logits:为True时，表示预测结果非概率分布，而是确切的类别值；
            为False时表示输出是概率分布
'''
tf.keras.metrics.CategoricalCrossentropy(
    name='categorical_crossentropy', dtype=None, 
    from_logits=False,label_smoothing=0
)
m = tf.keras.metrics.CategoricalCrossentropy()
m.update_state([[0, 1, 0], [0, 0, 1]],
               [[0.05, 0.95, 0], [0.1, 0.8, 0.1]])
'''
# EPSILON = 1e-7, y = y_true, y` = y_pred
# y` = clip_ops.clip_by_value(output, EPSILON, 1. - EPSILON)
# y` = [[0.05, 0.95, EPSILON], [0.1, 0.8, 0.1]]
# xent = -sum(y * log(y'), axis = -1)
#      = -((log 0.95), (log 0.1))
#      = [0.051, 2.302]
# Reduced xent = (0.051 + 2.302) / 2
'''
print('Final result: ', m.result().numpy())  # Final result: 1.176

6、tf.keras.metrics.SparseCategoricalAccuracy

1
2
3
4

m = tf.keras.metrics.SparseCategoricalAccuracy() 
_ = m.update_state([[2], [1]], [[0.1, 0.9, 0.8], [0.05, 0.95, 0]]) 
m.result().numpy() 
#输出：0.5

7、tf.keras.metrics.SparseCategoricalCrossentropy

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

m = tf.keras.metrics.SparseCategoricalCrossentropy()
m.update_state(
  [1, 2],
  [[0.05, 0.95, 0], [0.1, 0.8, 0.1]])
'''
# y_true = one_hot(y_true) = [[0, 1, 0], [0, 0, 1]]
# logits = log(y_pred)
# softmax = exp(logits) / sum(exp(logits), axis=-1)
# softmax = [[0.05, 0.95, EPSILON], [0.1, 0.8, 0.1]]
# xent = -sum(y * log(softmax), 1)
# log(softmax) = [[-2.9957, -0.0513, -16.1181], [-2.3026, -0.2231, -2.3026]]
# y_true * log(softmax) = [[0, -0.0513, 0], [0, 0, -2.3026]]
# xent = [0.0513, 2.3026]
# Reduced xent = (0.0513 + 2.3026) / 2
'''
print('Final result: ', m.result().numpy())  # Final result: 1.176

数据预处理形式

图片数据建模示例

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

import tensorflow as tf 
from tensorflow.keras import datasets,layers,models
BATCH_SIZE = 100
# 图片预处理
def load_image(img_path,size = (32,32)):
    label = tf.constant(1,tf.int8) if tf.strings.regex_full_match(img_path,".*automobile.*") \
            else tf.constant(0,tf.int8)
    img = tf.io.read_file(img_path)
    img = tf.image.decode_jpeg(img) #注意此处为jpeg格式
    img = tf.image.resize(img,size)/255.0
    return(img,label)
#使用并行化预处理num_parallel_calls 和预存数据prefetch来提升性能
# 遍历文件夹， 对图片数据做预处理， shuffle， 预存数据
ds_train = tf.data.Dataset.list_files("../../data/cifar2/train/*/*.jpg") \
           .map(load_image, num_parallel_calls=tf.data.experimental.AUTOTUNE) \
           .shuffle(buffer_size = 1000).batch(BATCH_SIZE) \
           .prefetch(tf.data.experimental.AUTOTUNE)  
ds_test = tf.data.Dataset.list_files("../../data/cifar2/test/*/*.jpg") \
           .map(load_image, num_parallel_calls=tf.data.experimental.AUTOTUNE) \
           .batch(BATCH_SIZE) \
           .prefetch(tf.data.experimental.AUTOTUNE)  
# 迭代器取一张
# 可以使用ds_train.take(1)

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

# ------------------
# Keras保存模型结构及权重
# ------------------
model.save('data/keras_model.h5')  
del model  #删除现有模型
# identical to the previous one
model = models.load_model('data/keras_model.h5')
json_str = model.to_json()
model_json = models.model_from_json(json_str)
print(json_str)
print(model_json)
# ------------------
# tensorflow保存权重
# ------------------
model.save_weights('../../data/tf_model_weights.ckpt',save_format = "tf")
# 保存模型结构与模型参数到文件,该方式保存的模型具有跨平台性便于部署
model.save('../../data/tf_model_savedmodel', save_format="tf")
print('export saved model.')
model_loaded = tf.keras.models.load_model('../../data/tf_model_savedmodel')
# model_loaded.evaluate(x_test,y_test)

文本数据预处理方式

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
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50

# 1. tf.keras.preprocessing中的Tokenizer词典构建工具和tf.keras.utils.Sequence构建文本数据生成器管道
# https://zhuanlan.zhihu.com/p/67697840
# 2. tf.data.Dataset 和 keras.layers.experimental.preprocessing.TextVectorization预处理
MAX_WORDS = 10000  # 仅考虑最高频的10000个词
MAX_LEN = 200  # 每个样本保留200个词的长度
BATCH_SIZE = 20 
def split_line(line):
    arr = tf.strings.split(line, "\t")
    label = tf.expand_dims(tf.cast(tf.strings.to_number(arr[0]), tf.int32), axis=0)
    text = tf.expand_dims(arr[1], axis=0)
    return text, label
# 处理文件夹，并行处理
ds_train_raw =  tf.data.TextLineDataset(filenames = [train_data_path]) \
   .map(split_line,num_parallel_calls = tf.data.experimental.AUTOTUNE) \
   .shuffle(buffer_size = 1000).batch(BATCH_SIZE) \
   .prefetch(tf.data.experimental.AUTOTUNE)
ds_test_raw = tf.data.TextLineDataset(filenames = [test_data_path]) \
   .map(split_line,num_parallel_calls = tf.data.experimental.AUTOTUNE) \
   .batch(BATCH_SIZE) \
   .prefetch(tf.data.experimental.AUTOTUNE)
def clean_text(text):
    lowercase = tf.strings.lower(text)
    stripped_html = tf.strings.regex_replace(lowercase, '<br />', ' ')
    cleaned_punctuation = tf.strings.regex_replace(stripped_html,
         '[%s]' % re.escape(string.punctuation),'')
    return cleaned_punctuation
vectorize_layer = TextVectorization(
    standardize=clean_text,
    split = 'whitespace',
    max_tokens=MAX_WORDS-1, #有一个留给占位符
    output_mode='int',
    output_sequence_length=MAX_LEN)
ds_text = ds_train_raw.map(lambda text,label: text)
vectorize_layer.adapt(ds_text)
print(vectorize_layer.get_vocabulary()[0:100])
#单词编码
ds_train = ds_train_raw.map(lambda text,label:(vectorize_layer(text),label)) \
     .prefetch(tf.data.experimental.AUTOTUNE)
ds_test = ds_test_raw.map(lambda text,label:(vectorize_layer(text),label)) \
     .prefetch(tf.data.experimental.AUTOTUNE)

时序数据预处理方式

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
31
32
33
34
35
36
37
38
39
40
41
42

df = pd.DataFrame()
df['confirmed_num'] = [15, 12, 13]
df['cured_num'] = [13, 12, 12]
df['dead_num'] = [10, 123, 134]
df['date'] = ['2020-01-02', '2020-02-02', '2020-03-02']
df = df.set_index("date")
print(df)
# 做差分处理
dfdiff = df.diff(periods=1).dropna()
dfdiff = dfdiff.reset_index("date")
print(dfdiff)
"""
confirmed_num  cured_num  dead_num
date                                          
2020-01-02             15         13        10
2020-02-02             12         12       123
2020-03-02             13         12       134
         date  confirmed_num  cured_num  dead_num
0  2020-02-02           -3.0       -1.0     113.0
1  2020-03-02            1.0        0.0      11.0
"""
#用某日前3天窗口数据作为输入预测该日数据
WINDOW_SIZE = 3
def batch_dataset(dataset):
    dataset_batched = dataset.batch(WINDOW_SIZE,drop_remainder=True)
    return dataset_batched
# 取window_size个数据，然后shift
ds_data = tf.data.Dataset.from_tensor_slices(tf.constant(dfdiff.values,dtype = tf.float32)) \
   .window(WINDOW_SIZE,shift=1).flat_map(batch_dataset)
print(list(ds_data.as_numpy_iterator()))
ds_label = tf.data.Dataset.from_tensor_slices(
    tf.constant(dfdiff.values[WINDOW_SIZE:],dtype = tf.float32))
print(list(ds_label.as_numpy_iterator()))
#数据较小，可以将全部训练数据放入到一个batch中，提升性能
ds_train = tf.data.Dataset.zip((ds_data,ds_label)).batch(2).cache()

Jupiter 查看文档； 导出代码成py

简介

对话机器人的任务类型可以分为三类：

第一类是任务型对话，主要解决如订机票、订酒店等问题。它涉及的技术包括：语义理解、意图识别、状态追踪、对话决策等；

第二类是知识型对话，在寿险客服的场景里，用户可能会问“你这个保险要交多少钱？”这类问题。它涉及的技术包括：文本表示、语义匹配、知识图谱等；

第三类是闲聊型对话，用户可能只想找人聊聊天，对话不涉及到知识或业务，比如说“今天天气真好”。它涉及的技术包括：文本生成模型、文本检索、排序技术等；

Transformer: https://zhuanlan.zhihu.com/p/59629215

Self-attention: 编码器对特定单词编码时查看输入序列的其他单词

解码器中 Encoder-Decoder Attention 帮解码器注意输入句子的相关部分

多头注意力机制

这篇文章通过增加一种称为“多头”注意力的机制完善了self-attention层。这通过两种方式改善了注意力层的性能：

1. 它扩展了模型关注不同位置的能力。在上面的例子中，Z1包含了每个其他编码的一点，但它可能由实际的单词本身支配。翻译句子：“The animal didn’t cross the street because it was too tired”，我们很想知道这里的“it”指代什么？ 这时候会很有帮助。
2. 它给予attention层多个“表达子空间”。接下来会看到多头注意力有多组Query/ Key /Value权重矩阵（Transformer使用了8组注意力头，所以这里我们为每个编码器/解码器设置了8组），而不是简单的一组。每组集合都是随机初始化。之后在训练中每组用于将词嵌入（或来自较低层编码器/解码器的输出）映射到不同的表达子空间。

位置编码

这是因为左边的值是由一个函数(正弦)产生的，右边的值是由另一个函数(余弦)产生的。然后将它们连接起来形成每个位置编码向量

残差连接

全文内容均节选自E大雪球、有知有行等E大文章

https://xueqiu.com/4776750571/34758228

经过市场的毒打，确信一点，目前的我尚不适合选股，需要学习更多的知识。当前资产配置仍以ETF为主。

从失误的操作中学习，为什么三一翻车，为什么买啥跌啥

独立思考，用一种批判性思维去客观评价所有的言论和看法。

全市场70多倍PE，超过6倍PB就别买指数了。

不用使用主观判断，使用投资体系和投资策略中的机械化操作去进行投资。投资体系中的参数需要我们去设计，最差情境就是其中一环，当我们买的东西出现最差情况时，我会不会死。甚至出现比预期的还要差，黑天鹅，会不会死，这就是为什么要写最大下跌幅度xx, 已经做好准备到那里了

做好预期管理，正确交易和良好的心理，做好预案，知道品种涨了和跌了该作什么。

指标

看一个行业：基本面+技术面。基本面就是消息、新闻，技术面就是各种指标，KDJ、MACD等等。

MACD金叉是指MACD的快线DIF线自下而上穿越DEA慢线，MACD则由绿柱转为红柱，代表了股价由下跌开始转为抬升，意味着多头市场的开始，按照金叉位置与零轴线关系的不同，可以分为零上金叉和零下金叉。

零上金叉：是指DIF和DEA都位于零轴上方的时候所形成的金叉

零下金叉：指在DIF和DEA都是位于零轴下方的时候，DIF上穿DEA所形成的金叉。

MACD死叉指DIF快线自上而下穿越DEA慢线，MACD柱线由红柱转变为绿柱

零上死叉：下跌概率大

零下死叉：下跌幅度会小

KDJ:

紫线> 100, 高位，黄线K线超过80，处于超买区间，小于20处于超卖区间

长赢指数投资——节选自E大

家庭资产配置

一定要配置 大盘股+小盘股，大盘股抗跌，小盘股增收

某些时段，大小盘股片会表现不同力度的上涨。最佳策略是同时持有大小盘，动态平衡，谁涨的多就卖一些，买入涨的少的。在熊市初期和中期，尽量持有大盘股指数，估值回归到正常情况下，加大力度加仓小盘股。

中证500与中小板指，两支配一支，选择500，覆盖范围广，波动率大

创业板和500怎么选择，等创业板跌下来，建仓或移仓

大的选50和300.小的选500和创业

行业指数作为宽基的补充，有必要配置长期持有

行业指数的配置比例要低于宽基。未来路线图已经清洗，50，300，500，创业，医药和消费指数，关键在于，一定要大小搭配

（1）不要孤注一掷

（2）买入相关性低的ETF，对于相关性高的品种，也没有必要开网格

(3) 国内股票（大小）、境外成熟市场、境外新兴市场、债券、现金类、原油、贵金属、房地产、外汇。单个品种配置不低于5%。也不要高于30%

收益再提升

固定股债比例，季末年末平衡

根据估值动态调整股债比例

1. 增强指数基金
2. 优质的行业基金（医药+消费+科技+中概互联）
3. 优质的主动基金

首先，确定我的调仓周期。最低不要低于三个月，最高不要超过一年。

其次，确定最高最低仓位。股票仓位不要超过80%～85%

第三，确定品种。增强或标准宽基指数基金（50，300，500，1000，创业，科创）与优质行业基金结合

第四，考虑目前合适的仓位

第五，定期实施我的计划

网格

网格就是吃短期波动的策略。操作如下：

买入某个品种，设定买入幅度，比如3%或者5%，每跌到这个幅度，就继续买一格，记录下买入价格和数量。当价格上涨3%或者5%，就卖出获利的那一格。周而复始。

网格只是一个吃短期波动的小策略，赚大钱是不可能的，但是它能够有效提高资金利用率，并在波动市中游刃有余

更要注意的是，资金分配的问题。开网之前做压力测试，至少给60%下跌幅度，测算自己的投入金额是否能承受这个跌幅。

风险控制，E大微博提供的思路：

另外就是，很多朋友其实对于投资品种的性质、分配资金还有数学没有结合起来看。

比如我们说军工指数，波动大不大，大。估值高不高，高。那么能不能买？

你问我能不能买，我根本就不可能用一句话告诉你。这里面最关键的问题在于：买多少。

你用95%的资金去买银行理财，4%收益率。用5%的资金买军工。表面上看起来，你买军工了，风险巨大。但实际上呢？你根本就没有风险。或者说风险极小。为什么，因为即使军工一年跌50%，你这一年依然是正收益，不赔钱。

理解了这个思路，你就可以根据自己的情况设计一个符合自己风险/收益的组合。

你需要做两件事：

第一，翻出每次发车文章中对于某个指数基金的“最大跌幅”。

第二，拿出一张纸，一根笔，按照自己的情况开始计算。

如果你永远不希望资金回撤，那么你就按照上面的方式，绝对不会赔钱的品种和高风险品种，按照高风险品种最大回撤计算两者应该买多少，即使高风险品种跌到最大跌幅，你也不会赔钱。

这样做的好处是什么呢，是你完全没有提高自己的风险的情况下，却将自己有可能获得的收益从固定的4%提高了很多，因为高风险品种有可能大涨。

如果你觉得没必要保证完全不赔钱，那么你就设定允许自己一年最多赔多少，比如10%。然后就按照这个风险承受度去再配置。降低无风险品种的仓位，提高高风险的仓位。

所以我绝对不同意说什么可以买，什么不能买。最重要的是，你用多少钱去买，你愿不愿意承受这里面的风险和收益。

所以，你就应该理解，为什么我们的计划越跌仓位越大，越涨仓位越小。很简单，因为我们承受的风险不变，但预期收益会越来越高。或者是预期收益不变，风险越来越低。

打新

打新的关键是选择门票股。每个季度当季报公布完毕，通过一些量化手段选出一批门票股。根据某些成长+估值的指标，选出一大批，等权买入。

其次，可以关注一些经过历史考验的，牛人投资者。他们会长期看好一些股票，可以抄作业。当作一个成分股，作为一部分买入。

长期看好的品种

有些品种是未来几十年都可以长期看好的，只要有大幅回调就可以买，然后长期持有+波段降成本。医药、消费、信息产业

六大目标指数：300、500、创业、科创、科技、消费、医药、50（被去掉）

估值分析

以中证500为例，研究它过去几年的PE数据，选出最高、最低的各三个月末，以及一个十年平均的月末，看看这估值不同的七个月到现在，收益率会有什么样的不同

https://youzhiyouxing.cn/n/materials/728

A股是个聚宝盆，但影响你长期收益的关键，是你什么时候进场。*大熊市入场买股票，十年十倍不是梦；大牛市进场，8 年 1 倍你就是王者。最糟的是，大牛市入场，你的收益率很可能 5 年还是负。

判断估值的方法

https://youzhiyouxing.cn/n/materials/729

一个指数的估值是否进入过去十年最高 10% 区域，具有非常非常重要的意义。通常情况下，某个指数进入过去十年最高 10% 区域，就是本人清仓区域。

重点关注的指标：

全市场PE、PB

指数的估值是否进入过去十年最高 10% 区域

五年平均PE、十年平均PE

全市场加权估值、深证综指 危险点40

按月分析各指数TTM pe值

长期：科学配置各类etf。低于平均开始买入，跌得越多买的越多。基本构成：上证50ETF（大盘，这货长期表现极佳，统计表以后有空贴出）；中证500ETF（中盘，长期表现极棒。几乎没有相对很弱的年份出现）；创业etf（小盘）；黄金ETF、恒生ETF、标普或德国ETF、消费ETF、医药ETF

对于一个股市整体来说，它所包含的股票不可能都一起高速成长而慢慢拉低市盈率。所以，对于一个股市整体来说，市盈率是非常非常非常重要的。

那么，现在中国A股的整体市盈率，以及整体估值如何呢？

对于市盈率的选择，有所谓的静态、动态、TTM 等。静态就以上一个财年盈利为基础，动态就是机构预测本财年末为基础，TTM 就是过去四个季度为基础。我觉得最可笑的就是动态市盈率，机构预测，笑死我算了。我这里用 TTM 市盈率。好，我们一起来看看，A股到底是贵还是便宜。（所有数据都是从 Wind 计算而出）

定投策略

定投最最最简单的策略，就是巴菲特所说的：

定时定额买指数，每个月找一个固定的日期，买入相同的金额的某个指数，然后终生持有。

这是定投的第一层，再高级一点呢？就会衍生出很多分支。比如一个分支可以这样做：

买入之后赔钱了，就每个月继续买。成本不断下降，到了盈亏平衡点不再买入，等待指数翻倍后卖出，再继续每个月买，周而复始。

再比如：

如果亏损了10%，下个月加码买入；亏损20%，再加码买入。这样回本的速度回更快，翻番后也会赚很多。

再比如：

找到某个指数的均线，在这个均线下开始定投，均线之上不买入，跌破均线清仓。

再比如：

计算某个指数的历史估值，根据历史估值低买高卖，按月操作。

总而言之，所有的好策略，都应该是让你克服恐惧，在越低的地方买的越多，越高的地方悄悄撤退。不为别的，只是为了能够克服人性的弱点。

当然了，亮点是大部分制定来策略的人，还是无法执行到底，因为无法长期坚持，最终执行不了也是人性。

对绝大多数人来说，你每一个阶段赚钱与否，赚了多少，可以说一点点都不重要，重要的是你在这段经历中学到了什么，有没有形成自己的投资体系，学到的东西在接下来的投资中会不会让你做得比以前更好。

现金管理

逆回购、增强货基、货基申赎统统搞起来。

现金管理和网格都是短期行为，打新股就是要控制仓位，不能占用太多资金。

国债逆回购

深市比沪市利息更低。

如何让后悔最小化

投资组合。在牛市中空仓和在熊市中满仓一样会让人痛苦不堪，那么你可以通过配置不同的资产，来达到合理的收益，让自己心态平衡。国安债，保护自己的投资，不要损失本金，这是最重要的。

亏了50%，就需要赚100%才能回本，每次投资前需要思考所买的标的的价值，是否能承担它的回撤。好好保护好我们投资的本金，不要乱投瞎投。

有时候，你看越多信息，只会让你的收益变低，每天都有信息给你，并不意味着能提高你的收益率，尤其是很多信息源根本毫无价值，只是因为数量多，善于拼凑信息，才有机会浪费你的时间。

投资策略

投资体系

1. 观察金融世界的体系

需要数据和工具去识别资金、情绪、估值等重要的东西

1. 完整的操作体系

交易策略

一个成熟的体系中，建议要有长期策略和短期策略。长期策略是用来赚增长+通胀的大钱，短期策略赚的是情绪以及波动。

另外，长期持仓品种，也可以叠加短期波段策略，这样会让你长期持仓的时候心态更加平和。这点非常非常重要。很多朋友害怕坐电梯，害怕已经盈利的品种又变成亏损，所以随意卖出导致赚不到大钱。如果你叠加了波段策略，及时实现一部分收益，那你的心态会有几何级的提升和改善。

如果没有网格吃波段的加成，80% 的人在上涨中拿不住赚钱的长期筹码。对于利润回撤的恐惧，是人类的天性。

如果没有长期仓位的支持，网格波段也会变成痛苦的根源。当你看着吃了几个点的品种一骑绝尘，就会痛苦不已。

什么是好的投资策略？

好的投资策略，就是能让你实现「低买高卖」的策略。在一个完整的，出色的投资策略中，一定是要包含低买和高卖两部分。所谓无论什么价格买都是好价格，或者买了一辈子都不卖这样的策略，碰到百分之一的好公司是没错，但绝大多数人买的股票，只有交易价值而已。

同时，好的策略应该是一个量化的策略，能让你坚定执行的、清清楚楚的策略。

制定好这样的策略后，只需要两点：耐心地等待、坚定地执行。

投资十三年，学习，总结并亲自用真金白银实践了不少投资策略。雪球高手云集，趋势策略不谈，只说价值策略，有四个经本人实践非常有效，同时简单易行。这四个策略，不需要高瞻远瞩行业前景，不需要实地调研公司内幕，难度系数可以说只有 2.0。

它们分别是：定期不定额、价值网格、目标市值、定期动态再平衡。

书籍推荐

巴菲特与索罗斯的投资习惯

邻家的百万富翁

漫步华尔街

股市长线法宝

有知有行笔记

股票：公司所有权，长期收益率最高的资产，复利，公司可以提高售价

债券：购买债券，我们就成了公司的债主

如何记账

目前而言，我会在各券商、支付宝、且慢等多个账户进行投资，如此一来，账户和资金就会分散且特别杂乱，那我们该如何记账呢。

一种方式是根据我们的投资目标来进行记账，比如在券商上买的基金都属于长期投资，我们可以以“长期复利”作为目标管理一个账本。短期我们也会做网格来吃网格收益，因此也可以为网格单独做一个账本

记账后关注哪些

1. 投资的结果

我们会经常看 累计收益 = 总资产 — 净投入

但同样也需要关注资金量和时间，花了多长时间赚了多少钱，这就是一个年化收益率的指标了。作为长期指标，短期内这个指标波动会特别大，没有参考意义，所以不会展示1个月内的年化收益

1. 过程是否符合预期

净值：将用户看作基金经理，以净值指标来评估用户的资金。

对比指标，和沪深300、中证500进行对比

记账频率建议按周或月

价值投资与实战笔记

格雷厄姆：低市盈率，三分之二市净率；

巴菲特：买的公司要有相应的资产、利润和现金流，而不仅仅是依靠未来成长的可能性来支撑其价值；

首先，ROE应与市盈率相挂钩。净资产收益率（ROE）为10%的公司，其正确的估值就应该是10倍市盈率。

PE/ROE，其实就是“市场价格”（市盈率）与“上市公司赚钱能力”（净资产收益率）的比值。当该值小于1时，即为低估值。

当ROE等于20%时，正确估值的市净率应为4倍；当ROE等于25%时，正确估值的市净率应为6.25倍；当ROE等于30%时，正确估值的市净率应为9倍。因此，ROE与市净率实际上应为“平方关系”。

有鉴于此，ROE等于20%的股票，价值投资的买入价最好是2倍市净率；ROE等于25%的股票，价值投资的买入价则最好是3.125倍市净率；ROE等于30%的股票，价值投资的买入价则最好是4.5倍市净率。

对企业价值的理解

对企业内在价值影响最大的，其实是未来现金流的折现，近三年盈利对企业的内在价值影响很小

策略：”看长做短”

买入的行业和板块，一定要有一年以上、偏中长期的投资逻辑，而不能只是几个月的利好。持有计划也应当是一年以上

“做短”：短期上涨太快，注意止盈

投资，不一定要赚大钱，而是慢慢用自己的分析和交易来赚钱，来培养自己对一种方法的自信。去改变之前自己那种冲动交易的风格，去相信事实、相信自己的分析，但也不要把运气当能力，不要去垃圾股里长黄金。没有人因为赚钱少而被市场淘汰，被淘汰的都是因为亏钱太多。

风格持续漂移的人赚不到什么钱，即看到什么涨，买什么，追热点很难赚到钱

逆向投资：

顺势赚快钱，逆势赚大钱；

巴菲特：别人恐惧我贪婪，别人贪婪我恐惧；

价值投资:

买入理由：低估值；ROE20%~30%稳定，企业核心价值的短期利空；企业正发生积极的变化；

卖出理由：逻辑变了，财报大幅低于预期；有更好的标的；估值高啦；

趋势投资：

1. 适合周期投资，无法预测未来的现金流
2. 适合牛市下半段使用
3. 周期股，牛市中后期，外汇产品

数据加载

1
2

dl_train = DataLoader(TensorDataset(torch.tensor(x_train).float(),torch.tensor(y_train).float()),shuffle = True, batch_size = 8)
dl_valid = DataLoader(TensorDataset(torch.tensor(x_test).float(),torch.tensor(y_test).float()),shuffle = False, batch_size = 8)

模型训练

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
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72

from sklearn.metrics import accuracy_score
loss_func = nn.BCELoss()
optimizer = torch.optim.Adam(params=net.parameters(),lr = 0.01)
metric_func = lambda y_pred,y_true: accuracy_score(y_true.data.numpy(),y_pred.data.numpy()>0.5)
metric_name = "accuracy"
epochs = 10
log_step_freq = 30
dfhistory = pd.DataFrame(columns = ["epoch","loss",metric_name,"val_loss","val_"+metric_name]) 
print("Start Training...")
nowtime = datetime.datetime.now().strftime('%Y-%m-%d %H:%M:%S')
print("=========="*8 + "%s"%nowtime)
for epoch in range(1,epochs+1):  
    # 1，训练循环-------------------------------------------------
    net.train()
    loss_sum = 0.0
    metric_sum = 0.0
    step = 1
    for step, (features,labels) in enumerate(dl_train, 1):
        # 梯度清零
        optimizer.zero_grad()
        # 正向传播求损失
        predictions = net(features)
        loss = loss_func(predictions,labels)
        metric = metric_func(predictions,labels)
        # 反向传播求梯度
        loss.backward()
        optimizer.step()
        # 打印batch级别日志
        loss_sum += loss.item()
        metric_sum += metric.item()
        if step%log_step_freq == 0:   
            print(("[step = %d] loss: %.3f, "+metric_name+": %.3f") %
                  (step, loss_sum/step, metric_sum/step))
    # 2，验证循环-------------------------------------------------
    net.eval()
    val_loss_sum = 0.0
    val_metric_sum = 0.0
    val_step = 1
    for val_step, (features,labels) in enumerate(dl_valid, 1):
        # 关闭梯度计算
        with torch.no_grad():
            predictions = net(features)
            val_loss = loss_func(predictions,labels)
            val_metric = metric_func(predictions,labels)
        val_loss_sum += val_loss.item()
        val_metric_sum += val_metric.item()
    # 3，记录日志-------------------------------------------------
    info = (epoch, loss_sum/step, metric_sum/step, 
            val_loss_sum/val_step, val_metric_sum/val_step)
    dfhistory.loc[epoch-1] = info
    # 打印epoch级别日志
    print(("\nEPOCH = %d, loss = %.3f,"+ metric_name + \
          "  = %.3f, val_loss = %.3f, "+"val_"+ metric_name+" = %.3f") 
          %info)
    nowtime = datetime.datetime.now().strftime('%Y-%m-%d %H:%M:%S')
    print("\n"+"=========="*8 + "%s"%nowtime)
print('Finished Training...')

图表展示

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

%matplotlib inline
%config InlineBackend.figure_format = 'svg'
import matplotlib.pyplot as plt
def plot_metric(dfhistory, metric):
    train_metrics = dfhistory[metric]
    val_metrics = dfhistory['val_'+metric]
    epochs = range(1, len(train_metrics) + 1)
    plt.plot(epochs, train_metrics, 'bo--')
    plt.plot(epochs, val_metrics, 'ro-')
    plt.title('Training and validation '+ metric)
    plt.xlabel("Epochs")
    plt.ylabel(metric)
    plt.legend(["train_"+metric, 'val_'+metric])
    plt.show()
    
plot_metric(dfhistory,"loss")

预测

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

#预测概率
y_pred_probs = net(torch.tensor(x_test[0:10]).float()).data
y_pred_probs
'''
tensor([[0.0119],
        [0.6029],
        [0.2970],
        [0.5717],
        [0.5034],
        [0.8655],
        [0.0572],
        [0.9182],
        [0.5038],
        [0.1739]])
'''
#预测类别
y_pred = torch.where(y_pred_probs>0.5,
        torch.ones_like(y_pred_probs),torch.zeros_like(y_pred_probs))
y_pred

保存模型参数

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

# 保存模型参数
torch.save(net.state_dict(), "../data/net_parameter.pkl")
net_clone = create_net()
net_clone.load_state_dict(torch.load("../data/net_parameter.pkl"))
net_clone.forward(torch.tensor(x_test[0:10]).float()).data
'''
# 保存模型
torch.save(net, '../data/net_model.pkl')
net_loaded = torch.load('../data/net_model.pkl')
net_loaded(torch.tensor(x_test[0:10]).float()).data
tensor([[0.0119],
        [0.6029],
        [0.2970],
        [0.5717],
        [0.5034],
        [0.8655],
        [0.0572],
        [0.9182],
        [0.5038],
        [0.1739]])
'''

使用说明

子仓库使用说明

克隆仓库

下列操作会克隆下主仓库和子仓库代码

1

git clone --recursive [库名]

拉取子仓库代码

更新所有子仓库代码

1

git submodule foreach git pull

提交更新

如果更新了主仓库中的内容，需要提交更新，可以按照下列步骤：

1. 先Fork一份到个人仓库下
2. 本地修改代码后，提交到个人仓库

1
2
3

git add .
git commit -m "代码修改"
git push origin master

1. 提交Merge

子仓库删除

1
2
3
4
5

git rm --cached {子仓库名}
rm -rf {子仓库名}
rm .gitmodules
vim .git/config 删除配置项中子模块相关条目

其他

添加子仓库并指定分支：

1

git submodule add -b dev [URL]

1
2
3
4
5

新建本地分支与远程分支关联
git branch –set-upstream 本地新建分支名 origin/远程分支名
例如：
git branch –set-upstream dev origin/dev
git branch --set-upstream-to=origin/dev dev

References

https://zhuanlan.zhihu.com/p/100214931

[TOC]

在贝壳一直做内容生成相关的工作，在此对过去大半年的工作做一个复盘和思考。

1.NLG的概念和意义

1.1 NLG简介

1.1.1 什么是NLG?

• 自然语言生成 - NLG 是 NLP 的重要组成部分。NLU 负责理解内容，NLG 负责生成内容，它的公式表达为NLP = NLU + NLG。以智能音箱为例，当用户说“几点了？”，首先需要利用 NLU 技术判断用户意图，理解用户想要什么，然后利用 NLG 技术说出“现在是6点50分”。NLG可以用于对话系统和一些需要机器内容

• 对于对话系统，有三种方式：

  • 规则模版。优势：实现简单，效果可控；劣势：缺乏多样性
  • 生成模型。seq2seq 和 transformer, 优势：无需规则；劣势： 效果不可控
  • 检索式模型。文本检索与排序从问答库中挑选；优点：数据来源于已生成的回复，通顺性高；劣势：不能生成新的回复文本

• NLG 可以将非语言格式的数据转换成人类可以理解的语言格式，如文章、报告等。目前NLG有2种方式：

​ （1）text-to-text：文本到文本的生成

​ （2）data-to-text：数据到文本的生成

白鹤林——《孤独》

从童年起，我便独自一人

照顾着

历代的星辰

顾城——《远和近》

你

一会儿看我

一会儿看云

我觉得

你看我时很远

你看云时很近

卞之琳——巜断章》

你站在桥上看风景

看风景人在楼上看你

明月装饰了你的窗子

你装饰了别人的梦

冯唐——巜春》

春水初生

春林出盛

春风十里 不如你

姜二嫚——《灯》

灯把黑夜烫了一个洞

深夜

我回忆着过去的一切

完整的人生

却变成了时间碎片

脑子里

只有那些刻骨铭心的喜怒哀乐

最是人间留不住，朱颜辞镜花辞树

最近变得十分恋旧，许多记忆的碎片在我的脑海里挥散不去。回想过去二十多年，经历了很多事，却又好像什么都想不起来。想慢慢收集这些记忆的碎片，组装拼接，回想过去的故事。

印象最深刻的自然就是曼曼了，多种神态历历在目：食堂里瞪我那一眼，一见钟情；听到要吃辣条时欢呼雀跃，蹦跳着跑去自强超市；诡计得逞时的嘴角偷偷上扬；拿着零食呆呆地故作思考吃不吃的神情；当然也有深夜里啜泣时的悲伤，生气时对我的不理不睬。千姿百态萦绕在我的脑海里，难以忘却。就从你给我的情书里回忆我们的过去吧！

初相遇

致亲爱的钊钊弟弟：

​ 初中，青春刚开始萌芽的时候，开始喜欢读书，读诗，每天活在自我的丰富与幻想中，那时候啊，深夜入睡前都是在席慕容的诗中度过的。

谨以下面这首诗与钊钊弟弟分享：

美丽的梦和美丽的诗一样

都是可遇而不可求的

常常在最没能料到的时刻里出现

我喜欢那样的梦

在梦里一切都可以重新开始

一切都可以慢慢解释

心里甚至还能感觉到

所有被浪费的时光

竟然都能重回时的狂喜和感激

胸怀中满溢着幸福

只因为你就在我眼前

对我微笑 一如当年

我真喜欢那样的梦

明明知道你已为我跋涉千里

却又觉得芳草鲜美 落英缤纷

好像你我才初相遇

​ 和钊钊弟弟的初相遇，是暑假新生群的初识，那时候的我呀，渴望着全新的大学生活，对一切都充满了期待、好奇、困惑，钊钊弟弟的头像那时候是柯南吧，一看就是小学生嘛。

​ 相识的时间最长，最信任，最喜欢的就是钊钊弟弟了呢。

​ 人生大概就是一场有规律的阴差阳错吧。

​ 小学毕业时，毫无伤感之说；初中毕业，哭得死去活来，没有想到高中时，还能遇到几个存放在内心深处的人，高中毕业，无依无靠，无所寄托，也万万没想到会在这个樱花的国度遇到你。大学零零落落加起来也有快一年了吧，旅途中有人来过，有人走了，有人从来没来过也从来不会来，谢谢钊钊弟弟，来了，没走，一直都在。

​ 我常在想啊，大概是上帝觉得我这个孩子太善良，所以总是给我惊喜，钊钊弟弟就是来自上帝吧，大概是上帝谋划了好久好久的礼物，因为，真的很珍贵啊！叫你钊钊弟弟，是因为我觉得，世上没有哪一种情感比亲情更长长久久，圆圆满满了，不止一次地跟最好的朋友们聊到你，“大学里，对我最好的就是钊钊弟弟了，能让我完完全全交出一颗真心的也就只有这么一个人了”。

​ 要找到一个不论欢乐和悲伤都能立即分享的人，在茫茫人海中，的确很不容易，钊钊弟弟要原谅我那么自私，把那么多伤心的事也分享给你，也要原谅我教会了你熬夜，害得你都胖不了，也许就是因为上辈子就认识，所以才会有那种一见如故的感觉。

​ 再仔细想一想，也许是上帝又觉得给了我太多把我宠坏了吧，从小就历经过无数次离别的我总是那么患得患失，每一次地全心全意付出，美景也很少能长久。过了暑假，钊钊弟弟就大四了呢，好难过啊，没有钊钊弟弟和曼曼姐姐一起疯了，那就又是孤孤单单的一个人了呢。不过呢，可别以为毕业了就能逃走了呢，我会像幽灵一样跟着你的呢！

爱的萌芽

​ 在我眼里，我和钊钊弟弟的缘分就像张爱玲所说的那样：于千万人之中，遇见你所要遇见的人。于千万年之中，时间的无涯的荒野里，没有早一步，也没有晚一步，刚巧赶上了，那也没有别的话可说，唯有轻轻地问一声：“奥，你也在这里吗？”

​ 希望和钊钊弟弟一起吃遍所有美食，一起看遍世上所有好景。

​ 嗯，过了今天，钊钊弟弟就又大了一岁，可是呀，曼曼姐姐希望你一直像现在这样，像个小学生多好，那样的话就没有什么事情是睡一觉和吃一顿火锅解决不了的啦，

​ 最后，送给钊钊弟弟一首歌，祝你生日快乐v - v。

《我要你好好的》

平凡的日子里，我们是谁

又扮演生活中，哪一类角色

各自的故事里，各自精彩

相聚时候一起

互相取暖

你好吗，亲爱的

我们都曾不太完整

直到碰面的这一刻

拥抱彼此，内心的伤

我想要你好好的

说着时光的话，谁最动听

我清楚那个你，不曾改变自己

孤单的情结里，独自彩排

我一直在复习

我最最亲爱的

你好吗 亲爱的

各自放心的努力活着

就算碰面的这一刻

还有好多想说的话

我喜欢你好好的

你好吗亲爱的

把心都交给彼此放着

就算碰面的这一刻

还有好多想说的话

我喜欢你好好的

你好吗 亲爱的

各自放心的努力过着

就算分开的每一天

还有彼此在心里撑

我想要你好好的

钊钊弟弟就是太傻了，曼曼姐姐最喜欢的人就是钊钊弟弟啦哈哈哈，但是就是因为太珍贵所以才不是那种喜欢～

总之呢，曼曼姐姐会和钊钊弟弟一直相亲相爱的哈～

钊钊弟弟，生日快乐，送你一个么么哒！

​ 2016.5.19

21岁

钊钊弟弟，傻宝，傻钊，笨猪，蠢蛋，二狗子

我发现喜欢一个人的表现之一就是给对方起各种名字。

你说过生日不好，又老了一岁

别怕哦，曼曼姐姐陪你长大

真喜欢这种每天在一起的感觉

21岁了，希望我宝每天开心，快乐健康

未来我们一起努力喔！

爱恋伊

22岁

亲爱的钊：

​ 祝你生日快乐！

​ 即使每天都在一起，也有许多话说不出口，需要借文字来传达。钊，祝福你在新的一岁里健康顺利。

​ 转眼已经一起度过了七百多个日夜，从最初的青涩到如今的无话不说，我们也算是一起经历了许多风雨，我现在已经不是那个能说出“和你在一起的每一天都是快乐的”这样的话的小女孩了，毕竟一年的三百六十五天里，你总要弄哭我几天，其实我也明白，无论什么情感都会随着时间的推移而改变，或褪色，或变深，爱情也是如此，当爱情的新鲜感带给我们的刺激开始衰减，各种各样的问题都会随之出现。很多时候我们都需要冷静下来想一想，我是真的深爱着我眼前的这个人吗？当岁月变迁，时间飞逝，当她容颜不再，我仍会深爱吗？很庆幸，每当我思考这些问题时，得到的答案都是肯定的，我确信眼前这个人就是我心中的那道光，尽管这个人有许多和我想象中不一样的地方，尽管这个人有时会给我带来伤害，尽管我也不知道这个人能否给我一个幸福的未来。

​ 其实，“未来”这个充满了希望的词带给我更多的是迷茫，无助，以及恐惧。我们还有太长的路要走，这中途有许多分叉路口，我根本不知道最终会去向何方，我也不知道我们，会不会在这中途失散，人生路真的好长，长到我总有一天会厌倦，但是现在，还是要好好活着，毕竟还没看遍大江南北。

​ 其实对于22岁的你，我有好多话想说。

​ 我希望我的男孩能变得更加成熟，做事，为人更加稳重，希望他能变得更有责任心，不管在什么方面，我也希望他能变得更加阳光，热爱运动，多出去走走，最大却最真实的愿望是希望他每天爱我多一点，把我当作他的宝贝，

​ 希望我和你能一直紧握双手，一起加油！

23岁

23岁的孙先生：

​ 生日快乐！

​ 时至今日，我才真正明白“时间是让人猝不及防的东西”的真正含义。大学生涯，从第一次加你为QQ好友，到第一次在机房与你见面，再到第一次约你出去玩，到现在即将迎来我们的三周年纪念日，每一天发生的事我都还历历在目。

​ 这四年遇到你是我最大的收获。

​ 坦诚来说，这一路走来我也有许多想放弃的时刻，有许多怀疑自己怀疑你的时刻，现在想来，还好我们都没有放弃。

​ 你总开玩笑说论文致谢中应该有你的名字，其实我的内心最感激的人就是你了，一直以来我都坚信爱是可以让人变好的东西。一份好的感情能让彼此成长，的确如此，我在这份感情里成长了太多，我从一个做什么事都畏畏缩缩的人变成了现在做事不再考虑太多后果的人。乐观，向上，认真，豁达，这些我都在慢慢向你学习，我喜欢这些改变，也喜欢现在的我，真心地感谢你。

​ 未来这两年对我们来说是一个考验，其实承诺在我看来并没那么重要，我也知道，生活中的变化并非都能由我们掌控，未来你会留在哪儿全凭你自己决定，我不希望也不会成为任何人的负担，我也会好好加油，不拖后腿。

​ 不管怎样，我们共同努力，期待一个有你的未来！

​ 祝我钊身体健康，前程似锦！

24岁

铛铛铛铛！亲爱的钊宝，曼宝祝你生日快乐！去年没在身边过生日，今年又没在身边过生日呜呜呜。24岁呢，第一要健康！第二要开心！第三要爱我哦！工作很忙也要注意多休息！今年就是有我的第四个生日了耶，第一次给你过生日还是让梦儿给你送的大礼包。

岁月如梭啊，爱你呦biubiubiu

25岁

亲爱的钊宝：

25岁生日快乐呀！从你20岁生日我让梦儿帮我送你零食算起，这已经是我陪你一起过的第5个生日啦，今年终于能在你身边一起，来之不易。

不知道为什么，总觉得这一年是我们一起成长最快的一年，或许是因为疫情，或许是因为结束异地，也或许是因为带你回家见家长，生活像开了二倍速，一直在催着我们长大，催着我们直面生活的挑战。你如约回汉，让我们的未来更清晰，如今，只等我顺利毕业，生活又会进入一个新的阶段，很高兴每个重要的时刻都有你陪伴。

25岁看上去是个不得了的数字，可能意味着更多责任、工作、家庭、社会都会给你更大的压力，但25岁也只是我们漫长人生中普普通通的一年，也会在忙碌、欢喜或者悠闲、烦恼的一天天中悄然而去，25岁是正年轻的时光，要用来爱，用来珍惜，用来感受，工作辛苦，生活也不易，但请务必要开心，愉快地度过每一天，物质上的缺乏我们可以慢慢积累，精神上的富足和充实才是幸福生活的秘诀。

好像在每个不同的阶段，我都会对人生有不同的感悟，在听过、看过、经历过一些事情之后才会明白一些道理，我们未来的生活可能也会遇到一些磨难，总会有坑在等着我们，毕竟很少有人的一生都是一帆风顺的，美好和幸运反而是这些困难衬托出的，我只希望未来的我们，不论何时，都能像现在，像此刻一样，心心相印，携手并行。

人总爱追求新鲜感，但好在即使已经一起经历过五个春夏秋冬，我们仍能像最初那样，不忘初心，如果说之前的日子里我对未来仍有很多怀疑和不确定，那么现在，我相信眼前这个你是值得我这一颗真心的，我非常愿意并且希望和眼前这个人一起度过漫长岁月。

世间没有谁能完全了解另一个人，我们也一样，不论是观念、看法、习惯、性格都不同，但我们可以因为爱互相包容，彼此尊重，未来也会一样。

很感激上天让我们相遇，一起成长，一起进步，互相欣赏，希望在新的一年里，我最爱的宝贝健康平安，工作顺利少加班，希望和我一起继续相爱。

祝宝生日快乐😁

后记

初相遇的青涩，爱情萌芽时的羞赧，21岁时的热恋，22岁时的希冀，23岁时的成长，24岁异地的悲伤，25岁团圆的幸福，弹指一挥间，我们的故事已经写了很多，我们的未来还有更多的美好要去书写。

以我敬佩的一个leader写过的话镇楼，原文链接：https://mp.weixin.qq.com/s/kq5ABn-88NKiS-PCS5iXsQ

在极为有限的时间内，评委们想听的不仅是你如何做的，更想听的是你如何总结和抽象拔高的—毕竟我们认为：“不是你做了什么而要晋升你；而是因为你做了这些事带来了业务的增长和你自己的成长，使得你本人的能力已经站在了下一个级别的台阶上，我们才会晋升你” ， 所以你的业绩产出和你能否通过述职显示出自己已经具备了你要晋升的这个级别的能力，这是要紧的。

最近忙于秋季的晋升述职，人生第一次，做ppt的过程中发现了很多的问题，在这里做下记录，姑且按照时间的顺序来吧。

前期准备

整体架构

在做述职PPT前，我就在思考自己该沿着什么样的思路讲好自己的工作，看了过去别人的PPT之后，整体的架构基本就是下面这种形式：

1. 介绍项目是什么（一句话概括）
2. 我们为什么要做这个项目（解决了什么问题，存在的价值）
3. 目前项目已取得的成果（核心指标）
4. 项目的整体架构概览（如果讲不清楚，就只讲自己负责的模块）
5. 项目各个模块的具体介绍（这个部分篇幅最长，突出工作量和难度，包括遇到了什么问题，解决思路，取得了什么样的效果提升）
6. 未来的工作规划，以及对目标岗位的工作规划

简单点说，如果是一个项目，就可以按照“是什么— 为什么—怎么做—结果怎么样”的思路来叙述，但是如果负责的是多个项目，就需要思考项目间内在的联系，把这多个项目整合起来，而不是一个一个介绍，这样到后面评委们就会忘了前面你讲了什么内容了。

以我这次述职为例，其中有一个模块内容生产做了很多工作，生产了A,B,C三种形式的内容，看似毫无联系，但是仔细思考，它们其实存在一个递进关系：先做了A，但是发现A存在不足，于是我们又尝试做B，A+B的模式取得了不错的效果，这就够了吗？我们开始思考新的内容形式，最终决定尝试做C。 这样层层递进的感觉，更有利于抓住评委们的思路。这里非常感谢我的Mentor给我的建议。

Docker常用命令

1. 先从dockerhub 中获取镜像内容
2. 运行镜像，查看镜像中已有环境是否满足需求

   镜像管理

   1 2 3

   docker pull ubuntu docker images docker search xxx

启动停止杀死,删除容器

1
2
3
4
5

docker start <container-id>
docker stop <container-id>
docker restart <container-id>
docker kill <container-id>(需要先停止才能杀死)
docker rm <container-id>

宿主机内容挂载&端口映射

内容挂载：相当于在容器中访问宿主机中文件
端口映射：访问宿主机上9888端口相当于访问容器9999端口

1

docker run -dit -p 9888:9999 -v <absolute-path>:/home/test ufoym/deepo:pytorch-py27-cu90 /bin/bash

列出所有容器id

1

docker ps -aq

进入后台运行的容器

1
2
3
4

docker exec -it <container-id> /bin/bash
或者
docker attach <container-id>

镜像保存与迁移

将正在运行的容器打包成镜像

1
2
3
4
5
6
7
8
9
10

# 会覆盖同名镜像
docker commit -m "commit_info" -a "author_name" <container-id> <image-id>:tag
docker commit 661e737faf25 explain:0.2
# 保存镜像到本地
docker save -o <tar_filename> <image-id>:tag
# 载入本地镜像
docker load --input centos_nginx.tar

也可以通过dockerfile的形式自由迁移镜像

dockerfile示例

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
31
32
33

ARG IMAGE_TAG=0.97
FROM <path>:${IMAGE_TAG}
# apt-get 安装所需软件
RUN apt-get --yes update && \
    apt-get --yes install --no-install-recommends \
        vim git ssh zip wget tmux lrzsz && \
    apt-get clean && \
    rm -rf /var/lib/apt/lists/*
# 安装 redis 5.0.5
RUN cd /usr/local/ && \
    wget http://download.redis.io/releases/redis-5.0.5.tar.gz && \
    tar xzf redis-5.0.5.tar.gz && \
    cd redis-5.0.5 && \
    make
ENV PATH='/usr/local/redis-5.0.5/src':$PATH
# pip 安装必需的库
RUN /usr/local/bin/python -m pip install --upgrade pip -i https://pypi.tuna.tsinghua.edu.cn/simple && \
    pip install jupyterlab -i https://pypi.tuna.tsinghua.edu.cn/simple
RUN pip install --no-cache-dir \
        Polygon3==3.0.8 \
        timeout_decorator==0.4.1
# 设置所需的环境变量
ENV POD_NAME='pod'
ENV NODE_NAME='node'
# 设置默认的工作目录
WORKDIR /

随后在Dockerfile 指定目录下执行，其中 . 表示目录路径

1

docker build -t <image-name>:<tag-name> .

常见问题

docker中文乱码解决

1
2
3
4
5
6
7

locale -a查看容器所有语言环境
修改/etc/profile文件
添加 export LANG=C.UTF-8
source /etc/profile
或者在制作dockerfile中添加
ENV LANG=C.UTF-8

docker部署tf-serving

1
2
3
4
5
6

# 在docker容器里启动tensorflow serving，把8501(rest)端口映射出来
-e 设置环境变量
docker run -t --rm -p 8501:8501 \
    -v "$TESTDATA/saved_model_half_plus_two_cpu:/models/half_plus_two" \
    -e MODEL_NAME=half_plus_two \
    tensorflow/serving &

docker ADD和COPY

参考链接：https://www.cnblogs.com/sparkdev/p/9573248.html

https://yeasy.gitbook.io/docker_practice/image/dockerfile/entrypoint

1
2
3
4
5
6
7
8
9
10

# 在容器中 checkredis.py 文件就是被复制到了 WORKDIR /app 目录下
WORKDIR /app
COPY checkredis.py .
COPY check* /testdir/           # 拷贝所有 check 开头的文件
COPY check?.log /testdir/       # ? 是单个字符的占位符，比如匹配文件 check1.log
# COPY 和 ADD 命令具有相同的特点：只复制目录中的内容而不包含目录自身。
WORKDIR /app
COPY nickdir ./nickdir

ADD 命令还可以解压压缩文件并把它们添加到镜像中

1
2

WORKDIR /app
ADD nickdir.tar.gz .

在使用 COPY 和 ADD 命令时，我们可以通过一些技巧来加速镜像的 build 过程。比如把那些最不容易发生变化的文件的拷贝操作放在较低的镜像层中，这样在重新 build 镜像时就会使用前面 build 产生的缓存。

1
2
3

WORKDIR /app
COPY myhc.py .
COPY check* ./

MakeFile 构建docker

MakeFile可以与Docker-compose结合使用

Docker Compose Compose 简介 Compose 是用于定义和运行多容器 Docker 应用程序的工具。通过 Compose，您可以使用 YML 文件来配置应用程序需要的所有服务。然后，使用一个命令，就可以从 YML 文件配置中创建并启动所有服务。

如果你还不了解 YML 文件配置，可以先阅读 YAML 入门教程。

Compose 使用的三个步骤：

1.使用 Dockerfile 定义应用程序的环境。

2.使用 docker-compose.yml 定义构成应用程序的服务，这样它们可以在隔离环境中一起运行。

3.最后，执行 docker-compose up 命令来启动并运行整个应用程序。

https://www.runoob.com/docker/docker-compose.html

示例：

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

version: '3'
services:
  <contrainer-name>:
    image: ''
    ports:
      - 8003:8000
    tty: true
    privileged: true
    runtime: nvidia
    environment:
      ENV_DEBUG: DEBUG
      PYTHONUNBUFFERED: 1
      PROCESS_NUMBER: 1
      NVIDIA_VISIBLE_DEVICES: all
      ENV_SL: ""
      ENV_BATCH_SIZE: 64
      ENV_API_PRIOR_TASK_RESP: ""
      ENV_MQ_CONSUMER_NUM: 0
      ENV_GPU: 0
#    volumes:
#      - ""

在当前目录创建一个叫做Makefile的文件。

声明变量

简单的变量赋值，比如声明name

1

name=ryan

声明规则Rule

Makefile文件由一系列规则（rules）构成。每条规则的形式如下。

1
2

<target> : <prerequisites> 
[tab]  <commands>

Docker构建用的指令 我常用的Makefile如下

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

NAME = ryan/airflow
VERSION = 1.10.4
.PHONY: build start push
build:  build-version
build-version:
        docker build -t ${NAME}:${VERSION}  .
tag-latest:
        docker tag ${NAME}:${VERSION} ${NAME}:latest
start:
        docker run -it --rm ${NAME}:${VERSION} /bin/bash
push:   build-version tag-latest
        docker push ${NAME}:${VERSION}; docker push ${NAME}:latest

构建一个版本的镜像

1

make build

构建完毕，运行一下镜像，看看内容是否正确

1

make start

最后推送到docker仓库

1

make push

pycharts

• pyecharts官网

参考官网上的示例我们可以可视化数据，渲染成html文件

注意：如果需要保存为图片，还需要安装selenium, phantomjs 和 pyppeteer 相应插件来处理

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

from pyecharts.charts import Bar
from pyecharts import options as opts
# V1 版本开始支持链式调用
# 你所看到的格式其实是 `black` 格式化以后的效果
# 可以执行 `pip install black` 下载使用
bar = (
    Bar()
    .add_xaxis(["衬衫", "羊毛衫", "雪纺衫", "裤子", "高跟鞋", "袜子"])
    .add_yaxis("商家A", [5, 20, 36, 10, 75, 90])
    .set_global_opts(title_opts=opts.TitleOpts(title="主标题", subtitle="副标题"))
    # 或者直接使用字典参数
    # .set_global_opts(title_opts={"text": "主标题", "subtext": "副标题"})
)
bar.render()
# 不习惯链式调用的开发者依旧可以单独调用方法
bar = Bar()
bar.add_xaxis(["衬衫", "羊毛衫", "雪纺衫", "裤子", "高跟鞋", "袜子"])
bar.add_yaxis("商家A", [5, 20, 36, 10, 75, 90])
bar.set_global_opts(title_opts=opts.TitleOpts(title="主标题", subtitle="副标题"))
bar.render()

PyGraphviz

• PyGraphviz (几何图形可视化工具) 简单入门
• Graphviz 是一个几何图形可视化软件，能够将数据的结构信息表示为抽象图形和网络图的方式。
• PyGraphviz 主要对数据量大、可任意定制的图形上具有强大优势。

安装：

1
2
3
4

brew install graphviz # mac
pip install graphviz # linux
conda install graphviz # conda
pip3 install pygraphviz

使用：

神经网络图

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
31
32
33
34
35
36
37
38
39
40
41
42

import pygraphviz as pgv
G = pgv.AGraph(directed=True, rankdir="LR")
# 设置层数、每层节点数
network_structure = input("输入神经网络每层节点数，如：[10, 7, 5, 4, 2, 1]\n")
all_nodes = [[f"layer{layer_index}node{node_index}" for node_index in range(layer_nodes_num)] for
             layer_index, layer_nodes_num in enumerate(eval(network_structure))]
# 添加输入层节点
for node_index, node in enumerate(all_nodes[0]):
    G.add_node(node, label="", shape="circle", style="bold", color="#60acfc", pos=f"0,{0.6 * node_index}!")
# 添加输入层文本
G.add_node(f"Input_Layer", shape="none", label=f"Input_Layer({len(all_nodes[0])})",
           pos=f"{0},{(node_index + 1) * 0.6}!")
# 添加中间层、输出层节点
for layer_index, layer in enumerate(all_nodes[1:]):
    color = "#5bc49f" if layer_index == len(all_nodes[1:]) - 1 else "#ff7c7c"
    for node_index, node in enumerate(layer):
        x = 1.5 * (layer_index + 1)
        y = - 0.3 * (len(all_nodes[layer_index + 1]) - len(all_nodes[0])) + 0.6 * node_index
        G.add_node(node, label="", shape="circle", style="bold", color=color, pos=f"{x},{y}!")
    # 添加中间层、输出层文本
    text = f"Output_Layer({len(all_nodes[-1])})" if layer_index == len(all_nodes[1:]) - 1 else f"Layer_{layer_index + 1}({len(layer)})"
    G.add_node(f"Layer_{layer_index + 1})", shape="none", label=text,
               pos=f"{x},{y + 0.4}!")
# 添加线
for layer_index in range(all_nodes.__len__() - 1):
    for start in all_nodes[layer_index]:
        for end in all_nodes[layer_index + 1]:
            G.add_edge(start, end)
# 导出图形
G.layout()
G.draw("神经网络.png")
# 运行代码，输入 [5, 10, 15, 15, 15, 10, 5, 1]

因子相关性

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
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48

import pygraphviz as pgv
G = pgv.AGraph(directed=True, rankdir="TB")
# 设置节点标签
Root = "道路交通流畅"
negative_1 = "平均延误时间"
negative_2 = "负荷度"
negative_3 = "小区位置"
negative_4 = "相对延误率"
negative_5 = "房屋密度"
negative_6 = "人口密度"
negative_7 = "总延误率"
negative_8 = "排队率"
negative_9 = "行驶时间"
positive_1 = "通行能力"
positive_2 = "公路层级"
positive_3 = "路网结构"
positive_4 = "行驶速度"
positive_5 = "路网长度"
positive_6 = "小区面积"
positive_7 = "内部道路密度"
positive_8 = "路网密度"
# 添加节点
G.add_node(Root, style="filled", shape="box3d", color="#feb64d")
for negative in [eval(_) for _ in dir() if _.startswith("negative")]:
    G.add_node(negative, style="filled", shape="ellipse", color="#CFDBF6")
for positive in [eval(_) for _ in dir() if _.startswith("positive")]:
    G.add_node(positive, style="filled", shape="ellipse", color="#B4E7B7")
# 添加边
G.add_edges_from([[Root, negative_1], [Root, negative_6], [Root, negative_8], [Root, negative_9],
                  [negative_1, negative_2], [negative_1, negative_7], [negative_2, negative_3],
                  [negative_2, negative_7], [negative_3, negative_4], [negative_8, negative_9],
                  [positive_2, negative_5], [positive_3, negative_4], [positive_4, negative_5]],
                 color="#B4DBFF", style="dashed", penwidth=1.5)
G.add_edges_from([[Root, positive_1], [Root, positive_8], [negative_5, negative_4],
                  [negative_6, positive_4], [negative_5, positive_4], [negative_9, positive_5],
                  [positive_1, positive_2], [positive_2, positive_3], [positive_6, positive_5],
                  [positive_7, positive_6], [positive_8, positive_7]],
                 color="#B4E7B7", style="dashed", penwidth=1.5)
# 导出图形
G.layout()
G.draw("因子相关性图.png", prog="dot")

SmartChart

smartchart

[toc]

Tree

108. 将有序数组转换为二叉搜索树

二叉搜索树的中序遍历就是一个有序数组，相当于是要根据中序遍历结果还原一棵二叉搜索树，代码如下：

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

class Solution {
    public TreeNode sortedArrayToBST(int[] nums) {
        return helper(nums, 0, nums.length-1);
    }
    private TreeNode helper(int[] nums, int start, int end) {
        if (start > end) {
            return null;
        }
        // 使用中间数字的右边数字作为根节点
        // int mid = (end - start + 1) / 2 + start;
        int mid = (end - start) /2 + start;
        TreeNode root = new TreeNode(nums[mid]);
        root.left = helper(nums, start, mid - 1);
        root.right = helper(nums, mid + 1, end);
        return root;
    }
}

105. 从前序与中序遍历序列构造二叉树

前序遍历的第一个节点就是根节点，随后递归执行,可以通过构造中序遍历的字典来快速查找中序遍历根节点，优化时间

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
31
32
33
34
35
36

class Solution {
    private Map<Integer, Integer> indexMap;
    public TreeNode myBuildTree(int[] preorder, int[] inorder, int preorder_left, int preorder_right, int inorder_left, int inorder_right) {
        if (preorder_left > preorder_right) {
            return null;
        }
        // 前序遍历中的第一个节点就是根节点
        int preorder_root = preorder_left;
        // 在中序遍历中定位根节点
        int inorder_root = indexMap.get(preorder[preorder_root]);
        
        // 先把根节点建立出来
        TreeNode root = new TreeNode(preorder[preorder_root]);
        // 得到左子树中的节点数目
        int size_left_subtree = inorder_root - inorder_left;
        // 递归地构造左子树，并连接到根节点
        // 先序遍历中「从 左边界+1 开始的 size_left_subtree」个元素就对应了中序遍历中「从 左边界 开始到 根节点定位-1」的元素
        root.left = myBuildTree(preorder, inorder, preorder_left + 1, preorder_left + size_left_subtree, inorder_left, inorder_root - 1);
        // 递归地构造右子树，并连接到根节点
        // 先序遍历中「从 左边界+1+左子树节点数目 开始到 右边界」的元素就对应了中序遍历中「从 根节点定位+1 到 右边界」的元素
        root.right = myBuildTree(preorder, inorder, preorder_left + size_left_subtree + 1, preorder_right, inorder_root + 1, inorder_right);
        return root;
    }
    public TreeNode buildTree(int[] preorder, int[] inorder) {
        int n = preorder.length;
        // 构造哈希映射，帮助我们快速定位根节点
        indexMap = new HashMap<Integer, Integer>();
        for (int i = 0; i < n; i++) {
            indexMap.put(inorder[i], i);
        }
        return myBuildTree(preorder, inorder, 0, n - 1, 0, n - 1);
    }
}

恢复二叉搜索树

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

class Solution:
    def recoverTree(self, root: TreeNode) -> None:
        """
        Do not return anything, modify root in-place instead.
        """
        """
        1. 找到二叉搜索树中序遍历得到值序列的不满足条件的位置。
        2. 如果有两个，维护一个prednode, 用x保存, 第二个交换的位置使用Y保存
        以 1234 -> 1432 为例，当cur = 3时， x=4 y=cur=3 
                             当cur=2时，仅更新y值 y=cur=2  x非空，跳出循环
        """
        stack = list()
        pred = x = y = None
        while root or stack:
            while root:
                stack.append(root)
                root = root.left
            if stack:
                curnode = stack.pop()
                if pred and curnode.val < pred.val:
                    y = curnode
                    if not x:
                        x = pred
                    else:
                        break
                pred = curnode
                root = curnode.right
        
        x.val, y.val = y.val, x.val

BFS

模版

1
2
3
4
5
6
7
8
9
10

while (!Q.empty())
{
    size = Q.size()
    for i in range 0..size
    {
        node = Q.pop()
        Q.push(node.left)
        Q.push(node.right)
    }
}

116. 填充每个节点的下一个右侧节点指针

O(1)空间解法

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

class Solution {
    public Node connect(Node root) {
        if (root == null) {
            return root;
        }
        Node x = root;
        while (x.left != null) {
            Node head = x;
            while (head != null) {
                head.left.next = head.right;
                if (head.next != null) {
                    head.right.next = head.next.left;
                }
                // 模拟层次遍历，遍历右子树
                head = head.next;
            }
            x = x.left;
        }
        return root;
    }
}

O(n)空间解法
Bfs

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

class Solution {
    public Node connect(Node root) {
        if (root == null) {
            return root;
        }
        Queue<Node> Q = new LinkedList<Node>(); 
        Q.add(root);
        while (!Q.isEmpty()) {
            int size = Q.size();
            for (int i = 0;i < size;i++) {
                Node x = Q.poll();
                if (i < size - 1) {
                    x.next = Q.peek();
                }
                if (x.left != null) {
                    Q.offer(x.left);
                }
                if (x.right != null) {
                    Q.offer(x.right);
                }
            }
        }
        return root;
    }
}

103. 二叉树的锯齿形层次遍历

Bfs遍历这棵树，在指定位置翻转结果

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 31 32 33 34 35 36 37 38

class Solution { public List<List<Integer>> zigzagLevelOrder(TreeNode root) { if (root == null) { return new ArrayList<List<Integer>>(); } List<List<Integer>> results = new ArrayList<List<Integer>>(); LinkedList<TreeNode> node_queue = new LinkedList<TreeNode>(); node_queue.offer(root); boolean is_left = true; while (!node_queue.isEmpty()) { LinkedList<Integer> array = new LinkedList<Integer>(); int size = node_queue.size(); for (int i =0;i < size;i++) { TreeNode node = node_queue.poll(); if (node.left != null) { node_queue.offer(node.left); } if (node.right != null) { node_queue.offer(node.right); } if (is_left) { array.add(node.val); } else { array.push(node.val); } } is_left = !is_left; results.add(array); } return results; } }

DFS

124. 二叉树中的最大路径和

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

class Solution {
    int maxSum = Integer.MIN_VALUE;
    public int maxPathSum(TreeNode root) {
        // 计算根节点最大收益
        int rootGain = maxGain(root);
        return maxSum;
    }
    public int maxGain(TreeNode root) {
        if (root == null) {
            return 0;
        }
        // 为负数则置0，不选择它，
        // 左子树最大收益
        int leftMax = Math.max(maxGain(root.left), 0);
        // 右子树最大收益
        int rightMax = Math.max(maxGain(root.right), 0);
        // 经过该节点的最大路径收益
        int gain = leftMax+rightMax + root.val;
        if (gain > maxSum) {
            maxSum = gain;
        }
        // 返回该节点的最大收益
        return root.val + Math.max(leftMax, rightMax);
    }
}

二分查找

二分查找的代码框架：

1
2
3
4
5
6
7
8
9

while (left<=right) {
		int mid = left + (right - left)/2;
    // 判断待查找的数与 mid 的数的关系，更新左右指针的位置
    if (target > arr[mid]) {
        left = mid + 1;
    } else if (target < arr[mid]) {
        right = mid - 1;
    }
}

搜索旋转排序数组

假设按照升序排序的数组在预先未知的某个点上进行了旋转。

( 例如，数组 [0,1,2,4,5,6,7] 可能变为 [4,5,6,7,0,1,2] )。

搜索一个给定的目标值，如果数组中存在这个目标值，则返回它的索引，否则返回 -1 。

你可以假设数组中不存在重复的元素。

你的算法时间复杂度必须是 O(log n) 级别。

示例 1:

输入: nums = [4,5,6,7,0,1,2], target = 0
输出: 4

示例 2:

输入: nums = [4,5,6,7,0,1,2], target = 3
输出: -1

思路：

1. 按照中间元素，可以将数组分为有序和无序两部分，
2. 分别判断 左侧子数组有序 和 右侧子数组有序 的情况
3. 对有序数组中执行二分查找操作，对无序数组重复上述操作。

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
31

class Solution {
    public int search(int[] nums, int target) {
        if (nums.length == 0) return -1;
        if (nums.length == 1) {
            if (nums[0] == target) return 0;
            else return -1;
        }
        int left = 0, right = nums.length - 1;
        while (left <= right) {
            int mid = left + (right - left) / 2;
            if (nums[mid] == target) return mid;
            if (nums[0] <= nums[mid]) {
                // 左侧数组为有序数组
                // target 在有序数组中，处理有序数组部分
                if (nums[0] <= target && target <= nums[mid]) {
                    right = mid - 1;
                } else {
                    left = mid + 1;
                }
            } else {
                // 右侧数组为有序数组
                if (nums[mid] <= target && target <= nums[right]) {
                    left = mid + 1;
                } else {
                    right = mid - 1;
                }
            }
        }
        return -1;
    }
}

排序数组中查找元素的第一个和最后一个位置

给定一个按照升序排列的整数数组 nums，和一个目标值 target。找出给定目标值在数组中的开始位置和结束位置。

你的算法时间复杂度必须是 O(log n) 级别。

如果数组中不存在目标值，返回 [-1, -1]。

示例 1:

输入: nums = [5,7,7,8,8,10], target = 8
输出: [3,4]
示例 2:

输入: nums = [5,7,7,8,8,10], target = 6
输出: [-1,-1]

来源：力扣（LeetCode）
链接：https://leetcode-cn.com/problems/find-first-and-last-position-of-element-in-sorted-array

思路：

1. 做两次二分查找，一次找起始位置，一次找结束位置
2. 找起始位置时，找到了target元素，右指针继续向左移动
3. 找结束位置时，左指针继续向右移动

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
31

public int[] searchRange(int[] nums, int target) {
    int[] result = {-1, -1};
    // 查找左区间
    int left = find(nums, target, true);
    if (left == nums.length || nums[left] != target) {
      return result;
    }
    result[0] = left;
    // 最终结果注意减 1
    result[1] = find(nums, target, false) -1;
    return result;
}
public int find(int[] nums, int target, boolean leftFlag) {
  int left = 0, right = nums.length - 1;
  while (left <= right) {
      int mid = left + (right - left) / 2;
      if (leftFlag && nums[mid] == target) {
        	right = mid - 1;
       		continue;
      }
      if (nums[mid] > target) {
        	right = mid - 1;
      } else
        	left = mid+1;
  }
  return left;
}

机器学习资料汇总

《统计学习方法》总结：

Python代码实现

Python代码实现+博客解析

李宏毅课程学习笔记

在线笔记

机器学习-李宏毅(2019) Machine Learning

Google机器学习

• Google Machine Learning Crash Course
• B站地址, google机器学习速成(基于tensorflow API)

周志华机器学习

周志华机器学习笔记

题目： https://leetcode-cn.com/problems/coin-change/

给定不同面额的硬币 coins 和一个总金额 amount。编写一个函数来计算可以凑成总金额所需的最少的硬币个数。如果没有任何一种硬币组合能组成总金额，返回 -1。

你可以认为每种硬币的数量是无限的。

1
2
3

输入：coins = [1, 2, 5], amount = 11
输出：3 
解释：11 = 5 + 5 + 1

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

def coinChange(self, coins: List[int], amount: int) -> int:
    # 自底向上的方法
    # 1. 定义状态 金额 的变化 
    # 2. 状态转移， dp[i] 当目标金额是i 时, 需要dp[i]个硬币
    # 3. 定义选择 coins列表, dp[i] = dp[i - coin] + 1
    #    选一个coin如5, 当目标金额是11时，dp[11] = dp[6] + 1, dp[6] = d[1] + 1, dp[1] = dp[0] + 1
    dp = [amount + 1] * (amount + 1)  # 最多要amount个硬币, 初始化为amount+1
    dp[0] = 0
    for i in range(len(dp)):
        for coin in coins:
            if i - coin < 0:
                continue
    				dp[i] = min(dp[i], dp[i - coin] + 1)
    if dp[amount] == amount + 1:  # 凑不出来的情况
        return -1
    return dp[amount]

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

def coinChange(self, coins: List[int], amount: int) -> int:
    # 自顶向上
    # 直接递归会有很多重复计算  例如 f(11) = f(5) + f(5) + f(1)
    # 空间换时间，先把f(5)存起来
    hashmap = dict()
    def dp(n):
        if n in hashmap:
            return hashmap[n]
        if n == 0:
            return 0
        if n < 0:
            return -1
        res = sys.maxsize
        for coin in coins:
            subproblem = dp(n - coin)
            if subproblem < 0:
                continue
            res = min(res, subproblem + 1)
        hashmap[n] = res if res != sys.maxsize else -1
        return hashmap[n]
    return dp(amount)

题目：https://leetcode-cn.com/problems/house-robber/

你是一个专业的小偷，计划偷窃沿街的房屋。每间房内都藏有一定的现金，影响你偷窃的唯一制约因素就是相邻的房屋装有相互连通的防盗系统，如果两间相邻的房屋在同一晚上被小偷闯入，系统会自动报警。

给定一个代表每个房屋存放金额的非负整数数组，计算你 不触动警报装置的情况下 ，一夜之内能够偷窃到的最高金额。

输入：[1,2,3,1]
输出：4
解释：偷窃 1 号房屋 (金额 = 1) ，然后偷窃 3 号房屋 (金额 = 3)。
偷窃到的最高金额 = 1 + 3 = 4 。

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

def rob(self, nums: List[int]) -> int:
    # 定义状态 金额
    # 定义选择 非相邻房屋
    # 定义 dp[i] 偷到第 i 个房屋，可以偷的最大金额
    # dp[i] = max(dp[i-1], dp[i-2] + nums[i])
    dp = [0] * len(nums)
    if not nums:
        return 0
    if len(nums) == 1:
        return nums[0]
    dp[0] = nums[0]
    dp[1] = max(dp[0], nums[1])
    if len(nums) == 2:
        return dp[1]
    for i in range(2, len(nums)):
        dp[i] = max(dp[i - 1], dp[i - 2] + nums[i])
    return dp[len(nums) - 1]

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

def rob(nums: List[int]) -> int:
    # i = 2
    # i % n-1 = 0
    if len(nums) == 1:
        return nums[0]
    if len(nums) == 2:
        return max(nums[0], nums[1])
    # 定义状态， 金额
    # 定义选择， 房屋 i
    # 定义状态转移 dp[i] = max(dp[i-1], dp[i - 2] + nums[i])
    # 不一样的是，本题中 第0个房子和第n-1个房子不能同时偷
    # 因此只需要求出 rob(nums[1:]) 和 rob(nums[:n-1]) 两种情况的最大金额，再取个最大值即可
    # 优化上一题，因为 dp[i]只与 dp[i-1]和dp[i-2]有关，因此可以只用两个变量表示，和斐波那契数列是一样的原理
    def func(nums):
        # 两个变量表示状态
        pre = 0
        cur = 0
        for i in range(len(nums)):
            cur, pre = max(cur, pre + nums[i]), cur
            return cur
    res = max(func(nums[0:len(nums) - 1]), func(nums[1:]))
    return res

参考博客：https://www.cnblogs.com/jbelial/articles/2116074.html

01背包问题

01背包问题

有N件物品和一个容量为V的背包。第i件物品的费用是c[i]，价值是w[i]。求解将哪些物品装入背包可使这些物品的费用总和不超过背包容量，且价值总和最大。

用子问题定义状态：即$f[i][v]$表示前i件物品恰放入一个容量为v的背包可以获得的最大价值。则其状态转移方程便是：$f[i][v]=max(f[i-1][v],f[i-1][v-c[i]]+w[i])$。

“将前i件物品放入容量为v的背包中”这个子问题，若只考虑第i件物品的策略（放或不放），那么就可以转化为一个只牵扯前i-1件物品的问题。

如果不放第i件物品，那么问题就转化为“前i-1件物品放入容量为v的背包中”；如果放第i件物品，那么问题就转化为“前i-1件物品放入剩下的容量为v-c[i]的背包中”，此时能获得的最大价值就是$f [i-1][v-c[i]]$再加上通过放入第i件物品获得的价值w[i]。

在数组中的两个数字，如果前面一个数字大于后面的数字，则这两个数字组成一个逆序对。输入一个数组，求出这个数组中的逆序对的总数。

链接：https://leetcode-cn.com/problems/shu-zu-zhong-de-ni-xu-dui-lcof

示例 1:

输入: [7,5,6,4]
输出: 5

链接：https://leetcode-cn.com/problems/coin-lcci

硬币。给定数量不限的硬币，币值为25分、10分、5分和1分，编写代码计算n分有几种表示法。(结果可能会很大，你需要将结果模上1000000007)

示例1:

输入: n = 5
输出：2
解释: 有两种方式可以凑成总金额:
5=5
5=1+1+1+1+1

示例2:

输入: n = 10
输出：4
解释: 有四种方式可以凑成总金额:
10=10
10=5+5
10=5+1+1+1+1+1
10=1+1+1+1+1+1+1+1+1+1

解决思路：

动态规划

定义 f(i, v) 表示前 i 种硬币构成面值为 v 的方案数，用 c[i] 表示第 i 种硬币面值

则
$$
f(i,v) = f(i-1, v-0 c[i]) + f(i-1, v-1c[i]) + … + f(i-1, v-kc[i])
$$
其中
$$
k<= v/c[i]
$$
举例说明： c={1,5,10,25}, 当i=4时，c[i]=25, 如果我们求前4种硬币构成50的方案数，则
$$
f(4, 50) = f(3, 50) + f(3, 50-125) + f(3, 50-225)
$$
优化
$$
f(i, v-c[i]) = f(i-1, v-c[i]) + f(i-1, v-2c[i]) + … + f(i-1, v-k*c[i])
$$
得到化简后的方程：
$$
f(i,v) = f(i-1, v) + f(i, v-c[i])
$$

1
2
3
4
5
6
7
8
9
10

class Solution:
	def waysToChange(self, n):
		mod = 10 ** 9 + 7
		coins = [25, 10, 5, 1]
		
		f = [1] + [0] * n
		for coin in coins:
			for i in range(coin, n+1):
				f[i] += f[i - coin]
		return f[n] % mod

链接：https://leetcode-cn.com/problems/count-number-of-nice-subarrays

给你一个整数数组 nums 和一个整数 k。

如果某个 连续 子数组中恰好有 k 个奇数数字，我们就认为这个子数组是「优美子数组」。

请返回这个数组中「优美子数组」的数目。

示例 1：

输入：nums = [1,1,2,1,1], k = 3
输出：2
解释：包含 3 个奇数的子数组是 [1,1,2,1] 和 [1,2,1,1] 。

示例 2：

输入：nums = [2,4,6], k = 1
输出：0
解释：数列中不包含任何奇数，所以不存在优美子数组。

示例 3：

输入：nums = [2,2,2,1,2,2,1,2,2,2], k = 2
输出：16

解题思路：

一. 滑动窗口

1. 定义两个指针和奇数个数，left, right, num, 控制right指针先遍历数组，遇到奇数则num++
2. 当奇数个数等于k时，即left~right窗口里包含k个奇数，且right在最右边界， 开始做以下处理：
   • right继续右移，直到遇到新的奇数，统计中间的偶数数量 rightEvenCount
   • left开始右移，直到遇到奇数，此时left为窗口左边界，统计移动过程中的偶数数量， leftEvenCount
   • 最终这个窗口的优美子数组数目为： (leftEvenCount + 1) * (rightEvenCount + 1)，结果加到最终返回的结果result中
   • right 继续遍历，重复上述操作

具体代码如下：

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

class Solution {
    public int numberOfSubarrays(int[] nums, int k) {
        int left=0, right=0, num=0;
        int res=0;
        while (right < nums.length) {
            if ((nums[right++] & 1)==1) {
                num++;
            }
            // 该滑动窗口中奇数为k个
            if (num == k) {
                int leftEven=0,rightEven=0;
                int temp = right;
                while (right < nums.length && (nums[right]&1)==0) {
                    right++;
                }
                rightEven = right-temp;
                while((nums[left]&1)==0) {
                    left++;
                    leftEven++;
                }
                res += (rightEven+1)*(leftEven+1);
                left++;
                num--;
            }
        }
        return res;
    }
}

二. 前缀项和

1. 定义 pre[i] 为[0:i]中奇数的个数
2. 每次遍历，计算当前数组的奇数个数sum，当sum>=k 时，在最终结果res中加上前缀项和为 sum - k 的个数

具体代码：

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

class Solution {
    public int numberOfSubarrays(int[] nums, int k) {
        int[] pre = new int[nums.length+1];
        int res=0, sum=0;
        pre[0] = 1;
        for (int num:nums) {
            sum += num & 1;
            // 截止此时，数组中有sum个奇数的数量
            pre[sum]++;
            if (sum >= k) {
                res += pre[sum - k];
            }
        }
        return res;
    }
}

在python中，除法有/ 和 // 两种，有着明显的区别，例子如下：

1
2
3
4
5
6
7
8
9
10
11

# py2中：
11 / 10 # 1
11.1 // 10 # 1.0 
-11 / 10 # -2
-11 // 10 # -2
# py3中
11 / 10 # 1.1
16 // 10 # 1
-12 / 10  # -1.2
-13 // 10 # -2

可以看出来，在py2中，无论用哪种方式，结果都是向下取整的，比如 -1.1 会向下取整为 -2, 而在py3中，只有”//“才会向下取整。

再说说取余操作，正数的取余操作没有问题，换成负数取余情况就诡异了，例子如下：

1
2
3
4
5
6
7
8
9

# py2中：
16 % 10 # 6
-16 % 10 # 4
-16 % -10 # -6
# py3中
16 % 10 # 6
-16 % 10 # 4
-16 % -10 # -6

为什么 -16 % 10会等于4呢，这里和python的底层机制有关，在python中

余数 R = a-n*[a//n]，其中R是余数，a是被除数，n是除数

在 a // n 这一步，当a是负数时，会向下取整，这也就得到 -16 - 10 *（-16//10）= 4

生如夏花般绚烂，死若秋叶般静美

突然肠胃炎发作，一副奄奄一息的样子，具体的病因现在还不知晓，每天活在被不适支配的恐惧和不安中，负面情绪更是影响了身边的人，一切都是那么的不如意。

读书时常常念叨，人生苦短，及时行乐，生亦何欢，死亦何苦。但当自己对这世上有了越来越多的牵挂后，我就越来越怕死了，害怕父母不能颐养天年，害怕女友伤心欲绝（额，好像也就剩这两部分牵挂了）。经常告诉自己，一定要好好活着，然而，厄运总比明天先到，自己在命运的玩笑面前，是那么的渺小无力，无奈无奈，什么都反抗不了，任由其宰割，但求自己能生如夏花般绚烂，死若秋叶般静美。

Hive优化

一. 表连接优化

1. 将大表放后头

Hive假定查询中最后的一个表是大表。它会将其它表缓存起来，然后扫描最后那个表。

1. 使用相同的连接键

当对3个或者更多个表进行join连接时，如果每个on子句都使用相同的连接键的话，那么只会产生一个MapReduce job。

1. 尽早过滤数据

2. 尽量原子化操作

尽量避免一个SQL包含复杂逻辑，可以使用中间表来完成复杂的逻辑

二. limit 语句快速出结果

一般情况下，Limit语句还是需要执行整个查询语句，然后再返回部分结果。

有一个配置属性可以开启，避免这种情况—对数据源进行抽样

hive.limit.optimize.enable=true — 开启对数据源进行采样的功能

hive.limit.row.max.size — 设置最小的采样容量

hive.limit.optimize.limit.file — 设置最大的采样样本数

三. 调整mapper和reducer的个数

1 Map阶段优化

map个数的主要的决定因素有： input的文件总个数，input的文件大小，集群设置的文件块大小（默认128M，不可自定义）。

举例：

a) 假设input目录下有1个文件a,大小为780M,那么hadoop会将该文件a分隔成7个块（6个128m的块和1个12m的块），从而产生7个map数

b) 假设input目录下有3个文件a,b,c,大小分别为10m，20m，130m，那么hadoop会分隔成4个块（10m,20m,128m,2m）,从而产生4个map数

即，如果文件大于块大小(128m),那么会拆分，如果小于块大小，则把该文件当成一个块。

map执行时间：map任务启动和初始化的时间+逻辑处理的时间。

1）减少map数

若有大量小文件（小于128M），会产生多个map，处理方法是：

1
2
3
4

set mapred.max.split.size=100000000; 
set mapred.min.split.size.per.node=100000000; 
set mapred.min.split.size.per.rack=100000000;  
set hive.input.format=org.apache.hadoop.hive.ql.io.CombineHiveInputFormat; -- 执行前进行小文件合并

– 前面三个参数确定合并文件块的大小，

大于文件块大小128m的，按照128m来分隔；

小于128m,大于100m的，按照100m来分隔；

把那些小于100m的进行合并

四. map端聚合

通过设置以下参数开启在Map端的聚合：

set hive.map.aggr=true;

相关配置参数：

1
2
3
4
5
6
7
8
9

hive.groupby.mapaggr.checkinterval  -- map端group by执行聚合时处理的多少行数据（默认：100000）
hive.map.aggr.hash.min.reduction -- 进行聚合的最小比例（预先对100000条数据做聚合，若聚合之后的数据量/100000的值大于该配置0.5，则不会聚合）
hive.map.aggr.hash.percentmemory  -- map端聚合使用的内存的最大值
hive.map.aggr.hash.force.flush.memory.threshold -- map端做聚合操作是hash表的最大可用内容，大于该值则会触发flush
hive.groupby.skewindata --是否对GroupBy产生的数据倾斜做优化，默认为false

四. 命令介绍

1
2

hive.auto.convert.join    默认值为true，自动开户MAPJOIN优化
hive.mapjoin.smalltable.filesize  默认值为2500000(25M),通过配置该属性来确定使用该优化的表的大小，如果表的大小小于此值就会被加载进内存中

学习链接：

hive参数
Hive性能优化
Hive调优
Hive坑
Hive调优
参数调优汇总

Fiddler使用参考链接

https://juejin.im/post/5c9779d76fb9a070b0486b08

工作以来，自我感觉编程能力上没有得到太大的提升，编程规范倒是进步明显。愈发感觉到写程序是一个“试错”的过程，第一版的代码永远都是那么丑陋不堪，写完多看两眼，多思考一下，总能想到改进的办法，这就是一种成长吧。不过更多的应该是思维方式和表达上吧，离高工还是有很大差距，记录下几点：

PPT注意事项

1. 对不同的受众，要合理把控PPT的内容
   • 在述职时，要着重凸显自己的工作带来的业务提升，总结抽象+拔高，加入自己的思考。整体上可以将自己的工作融合到一个大的框架中，过渡自然，突出结果，淡化过程
   • 在分享时，可以按照时间线的方式叙述，抛出问题->已有的方法->遇到的困难->自己的尝试->结果评估
   • 最重要的：核心的指标，量化产出；自己的思考
2. PPT是帮助我们总结沉淀的好工具，同事的PPT既可以让我获取一些素材，也可以了解他们的工作和思考
3. 多图少字，看图说话，突出指标

工作时思考方式：

1. 为什么做这件事，这件事的收益在哪里？（不过我想的永远没有老大们想的深入）
2. 做之前的数据评估，覆盖率？准确率？数据完整度？
3. 潜在的隐患，及时同步？怎么做能更易于扩展？
4. 效果回收，如何回收？评估指标？

所谓的方法论，在我看来，一方面就是对一个问题不停的细化拆解，考虑周全，思考做这件事的价值；另一方面，就是正向推导和反向推导，为了达到这个目的，我可以有哪些方法，不过最重要的，还是要拓宽自己的技术面，当自己了解的技术多了，对一件事情的解决方案就会变多，处理事情自然可以迎刃而解。

长路漫漫，唯剑作伴！

[TOC]

词向量就是把一个词表示成一个向量。简单的方式就是OneHot编码，但是这样做会造成维度灾难，且词与词之间没有关系。另一种方式是用一个向量来表示，维度一般不高，在空间上也可以计算距离来表示词与词之间的相似性。

基本概念

语言模型

语言模型就是给定一个词，预测后面的词在前面的词出现的情况下出现的概率。如果这个概率特别低，说明这句话不是一句自然语言。

$$p(s)=p(w_1)p(w_2|w_1)p(w_3|w_2,w_1)…p(wT|w{T-1} …w_1)$$

$p(w_1)$表示词$w_1$在语料库中出现的概率，考虑一个词前面所有的词来计算概率连乘的话，计算量会特别大，因此采用n-gram模型来进行优化。

n-gram模型

n-gram模型只考虑$w_i$前面的n-1个词，包括$w_i$本身，总共n个词，来计算在给定上文情况下，$w_i$出现的概率。也就是

$$p(w_i|Context_i)=p(wi|w{i-n+1} …w_{i-1})$$

N-gram模型也有些问题，总结如下：

1、n-gram无法建模更远的关系，大部分研究或工作都是使用trigram或bigram；

2、无法建模出词之间的相似度，就是有两个词经常出现在同一个context后面，但是模型是没法体现这个相似性的。

3、有些n元组（n个词的组合，跟顺序有关的）在语料库里面没有出现过，对应出来的条件概率就是0，这样一整句话的概率都是0了，这是不对的，解决的方法主要是两种：平滑法（基本上是分子分母都加一个数）和回退法（利用n-1的元组的概率去代替n元组的概率）

例如：students opened the book

（1）预测的文本 book ，语料库中没有students opened the book 这句话时，book的概率为0；可通过拉普拉斯平滑解决

（2）students opened the 在语料库中不存在时，计算概率值的分母为0；使用opened the 替代，称为backoff。

NNLM

神经网络语言模型使用NN直接取建模概率$p(w_i|Context_i)$,网络的输入是前n-1个单词的向量$C_i$，输出是V个节点，V就是词典大小，其中第$i$个节点的输出值就是$p(w_i|Context_i)$。模型结构如下：

训练的目标是最大似然加正则项：

​ $$L=max\frac{1}{T}\sum logf(wt,w{t-1},…,w{t-n+2},w{t-n+1};\theta)+R(\theta)$$

其中$\theta$为参数，$R(\theta)$为正则项，输出层采用softmax函数：

​ $$p(wt|w{t-1} …w{t-n+1})=\frac{e^{y{w_t}}}{\sum e^{y_i}}$$

其中$y_i$是每个输出词$w_i$的log概率，计算如下：

​ $$y=b+Wx+Utanh(d+Hx)$$

其中$x=(C(w{t-1}),C(w{t-2}),…,C(w_{t-n+1}))$, 输入层x也是要训练的参数，梯度更新的方式为：

​ $$\theta\leftarrow \theta+\alpha\frac{\partial logp(wt|w{t-1} …w_{t-n+1}))}{\partial \theta}$$

优化结束后，词向量和语言模型就都有了。

CBOW

CBOW是 Continuous Bag Words Model 的缩写，是一种 与前向 NNLM 类似 的模型，不同点在于 CBOW 去掉了最耗时的非线性隐层且所有词共享。 如

CBOW模型是根据上下文预测中心词。

这个网络结构的功能是为了完成一个的事情——判断一句话是否是自然语言。怎么判断呢？使用的是概率，就是计算一下这句话的“一列词的组合”的概率的连乘（联合概率）是多少，如果比较低，那么就可以认为不是一句自然语言，如果概率高，就是一句正常的话。

从输入层到隐层所进行的操作实际就是上下文向量的加和。原始代码如下(变量名也很随意呀)：

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

// in -> hidden
next_random = next_random * (unsigned long long)25214903917 + 11;
b = next_random % window;
cw = 0;
for (a = b; a < window * 2 + 1 - b; a++) if (a != window) {
    c = sentence_position - window + a;
    if (c < 0) continue;
    if (c >= sentence_length) continue;
    last_word = sen[c];
    if (last_word == -1) continue;
    for (c = 0; c < layer1_size; c++) 
       	neu1[c] += syn0[c + last_word * layer1_size]; // 一维数组存储向量参数
    cw++;
}

其中 sentence_position 为当前 word在句子中下标，b是0~window-1的一个值，整个窗口的大小为$2window+1-2b$，相当于左右给看$window-b$个词。最后将每个词的向量求和，赋值到neu1中

CBOW有两种可选的算法: 层次Softmax和 Negative Sampling。

层次Softmax算法结合了Huffman编码，每个词$w$都可以从树的根节点沿着唯一一条路径被访问到。如下图所示，我们可以沿着霍夫曼树从根节点一直走到我们叶子节点的目标词，其中，根节点就是简单求和平均后的词向量。这个霍夫曼树的所有叶子节点就代表了语料库里面的所有词，而且是每个叶子节点对应一个词，不重复。

在word2vec中，采用逻辑回归的方法判断，沿着左子树走为负类1，右子树为正类0

似然函数为：

$$f=\sigma(neu1^T\cdot syn1)$$

实质上就是将每一步的sigmoid求积，neu1表示平均后的词向量，syn1为模型参数，code[j]表示对于目标词w，第j个编码的哈夫曼取值，而我们的目标就是让这个概率最大，通过最大似然的方式求解。

$P(w|Context)=\prod ((f^{1-code[j]}))\cdot ((1- f)^{code[j]})$

$$L=-(1-code[j]logf - code[j]log(1-f))$$

解法选用的是SGD。具体说来就是对每一个样本都进行迭代，但是每个样本只影响其相关的参数，跟它无关的参数不影响。那么梯度就是：

$$Grad_{neu1}=\frac{\partial L}{\partial neu1}=-(1-code[j])\cdot (1-f)\cdot syn1+code[j]\cdot f\cdot syn1=-(1-code[j]-f)\cdot syn1$$

$$Grad_{syn1}=\frac{\partial L}{\partial syn1}=-(1-code[j])\cdot (1-f)\cdot neu1+code[j]\cdot f\cdot neu1=-(1-code[j]-f)\cdot neu1$$

代码如下：

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

if (hs) for (d = 0; d < vocab[word].codelen; d++) {
    f = 0;
    l2 = vocab[word].point[d] * layer1_size;
    // Propagate hidden -> output
    for (c = 0; c < layer1_size; c++) f += neu1[c] * syn1[c + l2];
    if (f <= -MAX_EXP) continue;
    else if (f >= MAX_EXP) continue;
    else f = expTable[(int)((f + MAX_EXP) * (EXP_TABLE_SIZE / MAX_EXP / 2))];
    // 'g' is the gradient multiplied by the learning rate
    g = (1 - vocab[word].code[d] - f) * alpha;
    // Propagate errors output -> hidden
    for (c = 0; c < layer1_size; c++) neu1e[c] += g * syn1[c + l2];
    // Learn weights hidden -> output
    for (c = 0; c < layer1_size; c++) syn1[c + l2] += g * neu1[c];
}

第二种算法是Negative Sampling，对一个词wij来说，这个词本身是一个正类样本，同时对这个词，还随机抽取了k个负类样本，那么每个词在训练的时候都有k+1个样本，所以要做k+1次SGD。每个样本的负对数似然就是

$f=-label\cdot log f- (1-label) \cdot log (1-f)$

推导过程与上文类似，只是把1 - code[j]替换成label

代码如下：

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

// NEGATIVE SAMPLING
if (negative > 0) for (d = 0; d < negative + 1; d++) {
    if (d == 0) {
        target = word;
        label = 1;
    } else {
        next_random = next_random * (unsigned long long)25214903917 + 11;
        target = table[(next_random >> 16) % table_size];
        if (target == 0) target = next_random % (vocab_size - 1) + 1;
        if (target == word) continue;
        label = 0;
    }
    l2 = target * layer1_size;
    f = 0;
    for (c = 0; c < layer1_size; c++) f += neu1[c] * syn1neg[c + l2];
    if (f > MAX_EXP) g = (label - 1) * alpha;
    else if (f < -MAX_EXP) g = (label - 0) * alpha;
    else g = (label - expTable[(int)((f + MAX_EXP) * (EXP_TABLE_SIZE / MAX_EXP / 2))]) * alpha;
    for (c = 0; c < layer1_size; c++) neu1e[c] += g * syn1neg[c + l2];
    for (c = 0; c < layer1_size; c++) syn1neg[c + l2] += g * neu1[c];
}

隐层为输入层各变量的加和，因此输入层的梯度其实就是隐层梯度，传播代码如下：

1
2
3
4
5
6
7
8
9

// hidden -> in
for (a = b; a < window * 2 + 1 - b; a++) if (a != window) {
    c = sentence_position - window + a;
    if (c < 0) continue;
    if (c >= sentence_length) continue;
    last_word = sen[c];
    if (last_word == -1) continue;
    for (c = 0; c < layer1_size; c++) syn0[c + last_word * layer1_size] += neu1e[c];
}

Skip-Gram

Skip-Gram和CBOW最大的区别就是表达模型输入输出的方式，对于Skip-Gram来说，训练的任务则变成了由目标词向量预估上下文的2c个词。最终的预估结果会是已知目标词，求上下文的条件概率。

为什么要是用层次化Softmax或Negative Sampling

一般的softmax方法是一个多分类的逻辑回归，分母要对所有词汇表里的单词求和，这使得计算梯度很耗时。

Hierarchical Softmax 使用的办法其实是借助了分类的概念。通过使用哈夫曼编码构造一连串两分类来近似原来的多分类，模型会赋予抽象的中间节点一个合适的向量。这种近似不会带来显著的效果损失，但同时提升了计算性能。

每次分类都会将数据分为两簇

语言模型公式就变成$P(A|C)=p(A|G,C)P(G|C)$.

Negative Sampling也是用二分类近似多分类，随机采样一些负样本，调整模型参数是的模型可以区分。换一个角度来看，就是 Negative Sampling 就稍微选几个词来算算，一般就需要按照词频对应的概率分布来随机抽样。

Reference

https://github.com/danielfrg/word2vec/blob/master/word2vec/includes/word2vec.c

https://blog.csdn.net/zynash2/article/details/81636338

https://blog.csdn.net/mytestmy/article/details/26961315

[TOC]

RPC

基本概念

摘自：https://www.jianshu.com/p/7d6853140e13

• RPC（Remote Procedure Call）远程过程调用，简单的理解是一个节点请求另一个节点提供的服务

• 本地过程调用：如果需要将本地student对象的age+1，可以实现一个addAge()方法，将student对象传入，对年龄进行更新之后返回即可，本地方法调用的函数体通过函数指针来指定。

• 远程过程调用

  上述操作的过程中，如果addAge()这个方法在服务端，执行函数的函数体在远程机器上，如何告诉机器需要调用这个方法呢？

  • 1.首先客户端需要告诉服务器，需要调用的函数，这里函数和进程ID存在一个映射，客户端远程调用时，需要查一下函数，找到对应的ID，然后执行函数代码。
  • 2.客户端需要把本地参数传给远程函数，本地调用的过程中，直接压栈即可，但是在远程调用过程中不再同一个内存里，无法直接传递函数的参数，因此需要客户端把参数转换成字节流，传给服务端，然后服务端将字节流转换成自身能读取的格式，是一个序列化和反序列化的过程。
  • 3.数据准备好了之后，如何进行传输？网络传输层需要把调用的ID和序列化后的参数传给服务端，然后把计算好的结果序列化传给客户端，因此TCP层即可完成上述过程，gRPC中采用的是HTTP2协议。

• 总结

  • Client端 ：Student student = Call(ServerAddr, addAge, student)

    1. 将这个调用映射为Call ID。

    2. 将Call ID，student（params）序列化，以二进制形式打包

    3. 把2中得到的数据包发送给ServerAddr，这需要使用网络传输层

    4. 等待服务器返回结果

    5. 如果服务器调用成功，那么就将结果反序列化，并赋给student，年龄更新

  • Server端

    1. 在本地维护一个Call ID到函数指针的映射call_id_map，可以用Map callIdMap

    2. 等待请求

    3. 得到一个请求后，将其数据包反序列化，得到Call ID

    4. 通过在callIdMap中查找，得到相应的函数指针

    5. 将student（params）反序列化后，在本地调用addAge()函数，得到结果

    6. 将student结果序列化后通过网络返回给Client

RPC架构

一个完整的RPC架构里面包含了四个核心的组件，分别是Client ,Server,Client Stub以及Server Stub。分别说说这几个组件：

• 客户端（Client），服务的调用方。
• 服务端（Server），真正的服务提供者。
• Client Stub，存放服务端的地址消息，再将客户端的请求参数打包成网络消息，然后通过网络远程发送给服务方。
• Server Stub，接收客户端发送过来的消息，将消息解包，并调用本地的方法。

为什么要用RPC

RPC效率更高，在传输例如图像这种大的字节流文件时速度比Http更快，主要原因有以下三点

• 1.减少传输量。
• 2.简化协议。
• 3.用长连接，不再每一个请求都重新走三次握手流程

RPC服务更适合用做线上分布式服务之间互相使用的通信协议。而HTTP服务开发迭代会更快。

gRPC

常见的RPC框架有：

1. gRPC。谷歌出品
2. Thrift。Apache出品
3. Dubbo。阿里出品，也是一个微服务框架

gRPC的4点特性：

1. 使用Protocal Buffers这个强大的结构数据序列化工具
2. grpc可以跨语言使用
3. 安装简单，扩展方便（用该框架每秒可达到百万个RPC）
4. 基于HTTP2协议

gRPC使用流程：

1. 定义标准的proto文件
2. 生成标准代码
3. 服务端使用生成的代码提供服务
4. 客户端使用生成的代码调用服务

protocol buffers是什么

谷歌开源的一种结构数据序列化的工具，比方说JSON、XML也是结构数据序列化的工具，不同的是，

1. Protocol Buffers序列化后的数据是不可读的，因为是二进制流
2. 使用Protocol Buffer需要事先定义数据的格式(.proto 协议文件)，还原一个序列化之后的数据需要使用到这个数据格式
3. Protocol Buffer 比 XML、JSON快很多，因为是基于二进制流，比字符串更省带宽，传输速度快

基于python的代码实践

目录结构：

1
2
3
4
5
6
7

grpc_test
	protos
		example.proto
	lightweight
		(generated_files)
	client.py
	server.py

example.proto

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

syntax = "proto3";
//命名空间
package lightweight;
//
service example {
    rpc Exp (Person) returns (Reply) {
    }
}
//Person 对象
message Person {
    string name = 1;
    int32 age = 2;
    repeated string actions = 3;
}
//结果对象
message Reply {
    int32 code = 1;
    string msg = 2;
}

编译 proto 文件生成服务接口

1

python -m grpc_tools.protoc -I=./protos --python_out=./lightweight --grpc_python_out=./lightweight ./protos/example.proto`

server.py

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
31
32
33
34
35

# coding=utf-8
'''
@author: sunyuzhao001@ke.com
@file: server.py.py
@time: 2021/1/11 20:16
@desc:
'''
from concurrent import futures
import logging
import grpc
# 支持新的包
import sys
sys.path.append("lightweight")
import lightweight.example_pb2_grpc as example_pb2_grpc
import lightweight.example_pb2 as example_pb2
class Example(example_pb2_grpc.exampleServicer):
    def Exp(self, request, context):
        print(f"{request.name}在思考, 内容: {list(request.actions)}")
        return example_pb2.Reply(code=0, msg='ok')
def serve():
    server = grpc.server(futures.ThreadPoolExecutor(max_workers=10))
    example_pb2_grpc.add_exampleServicer_to_server(Example(), server)
    server.add_insecure_port('[::]:50051')
    server.start()
    server.wait_for_termination()
if __name__ == '__main__':
    logging.basicConfig()
    serve()

client.py

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

# coding=utf-8
'''
@author: sunyuzhao001@ke.com
@file: client.py
@time: 2021/1/11 20:19
@desc:
'''
from __future__ import print_function
import logging
import grpc
# 支持导入新的包
import sys
sys.path.append("lightweight")
import lightweight.example_pb2_grpc as example_pb2_grpc
import lightweight.example_pb2 as example_pb2
def run():
    with grpc.insecure_channel('localhost:50051') as channel:
        stub = example_pb2_grpc.exampleStub(channel)
        response = stub.BodyBuilding(example_pb2.Person(
            name='xxx', actions=['学习', '看书', '哈哈']
        ))
    print(f'code: {response.code}, msg:{response.msg}')
if __name__ == '__main__':
    logging.basicConfig()
    run()

调试gRPC

rest api是可用curl和postman这样的工具来调试的，grpc也有类似的工具，对应的分别是grpcurl和grpcui（均基于go语言安装），其中grpcui类似于postman，有web页面帮助调试，用户友好。

示例代码

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

fib = lambda n: 1 if n <= 2 else fib(n - 1) + fib(n - 2)
def test1():
    fib(20)
def test2():
    fib(30)
def test3():
    fib(35)
if __name__ == '__main__':
    test1()
    test2()
    test3()

1. cProfile

cProfile是profile模块的c语言实现，二者实现的功能相同，但是cProfile的性能更佳。

使用方法:

1
2

~ python -m cProfile test.py
20132542 function calls (8 primitive calls) in 7.342 seconds

Ordered by: standard name

ncalls tottime percall cumtime percall filename:lineno(function)
20132537/3 7.342 0.000 7.342 2.447 test.py:1()
1 0.000 0.000 7.342 7.342 test.py:1()
1 0.000 0.000 6.707 6.707 test.py:12(test3)
1 0.000 0.000 0.006 0.006 test.py:4(test1)
1 0.000 0.000 0.630 0.630 test.py:8(test2)
1 0.000 0.000 0.000 0.000 {method ‘disable’ of ‘_lsprof.Profiler’ objects}

1
2
3
4
5
6
7
8

上述第一行表明，共有20132542次函数调用，其中8次是非递归调用。
列名 | 含义
---|---
ncalls | 总调用次数，```20132537/3```表名，共有20132537次调用，其中3次是非递归调用
tottime | 总调用时长
percall | 平均调用时长，其实就是```tottime```除以```ncalls

cumtime | 累计调用总时长，本函数以及本函数的递归调用累计调用时长
percall | 累计平均调用时长，其实就是

1
2
3
4
5
6
7
8
9

filename:lineno(function) | 函数名及入口代码地址
## 2. line_profiler
line_profiler模块可以给出执行每行代码所需占用的CPU时间。
首先，安装该模块：
``` 	
$ pip install line_profiler

接着，需要指定用

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

```Python
fib = lambda n: 1 if n <= 2 else fib(n - 1) + fib(n - 2)
@profilt
def test1():
    fib(20)
@profile
def test2():
    fib(30)
@profile
def test3():
    fib(35)
@profile
def main():
    test1()
    test2()
    test3()
if __name__ == '__main__':
    main()

最好，可以通过下面的命令获得关于

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
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47

```
~ kernprof -l  -v test.py
Wrote profile results to test.py.lprof
Timer unit: 1e-06 s
Total time: 0.00524 s
File: test.py
Function: test1 at line 3
Line #      Hits         Time  Per Hit   % Time  Line Contents
==============================================================
     3                                           @profile
     4                                           def test1():
     5         1          1.0      1.0      0.0      a=10
     6         1       5239.0   5239.0    100.0      fib(20)
Total time: 0.641574 s
File: test.py
Function: test2 at line 9
Line #      Hits         Time  Per Hit   % Time  Line Contents
==============================================================
     9                                           @profile
    10                                           def test2():
    11         1     641574.0 641574.0    100.0      fib(30)
Total time: 6.75469 s
File: test.py
Function: test3 at line 14
Line #      Hits         Time  Per Hit   % Time  Line Contents
==============================================================
    14                                           @profile
    15                                           def test3():
    16         1    6754692.0 6754692.0    100.0      fib(35)
Total time: 7.40158 s
File: test.py
Function: main at line 18
Line #      Hits         Time  Per Hit   % Time  Line Contents
==============================================================
    18                                           @profile
    19                                           def main():
    20         1       5274.0   5274.0      0.1      test1()
    21         1     641592.0 641592.0      8.7      test2()
    22         1    6754713.0 6754713.0     91.3      test3()

其中-l表示逐行解释，-v表示表示输出详细结果。
需要注意的是，

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

通过这种方法，我们看到```test3()```方法消耗了剩余的91.3%的时间。
标题 | 含义
---|---
Line # | 代码行号
Hits | 执行次数
Per Hit | 每次执行的平均执行时长
% Time | 该行执行时长占所在函数执行时长的占比
Line Contents | 实际代码内容
## 3. memory_profiler
memory_profiler模块可以给出执行每行代码所使用的内存。
安装该模块：
``` 	
$ pip install memory_profiler

同

1
2

~ python -m memory_profiler test.py
Filename: test.py

Line # Mem usage Increment Line Contents

3   34.945 MiB   34.945 MiB   @profile
4                             def test1():
5   34.945 MiB    0.000 MiB       a=10
6   34.953 MiB    0.008 MiB       fib(20)

Filename: test.py

Line # Mem usage Increment Line Contents

 9   34.953 MiB   34.953 MiB   @profile
10                             def test2():
11   34.961 MiB    0.008 MiB       fib(30)

Filename: test.py

Line # Mem usage Increment Line Contents

14   34.961 MiB   34.961 MiB   @profile
15                             def test3():
16   34.961 MiB    0.000 MiB       fib(35)

Filename: test.py

Line # Mem usage Increment Line Contents

18   34.938 MiB   34.938 MiB   @profile
19                             def main():
20   34.953 MiB   34.953 MiB       test1()
21   34.961 MiB   34.961 MiB       test2()
22   34.961 MiB   34.961 MiB       test3()

```

Mac 安装应用踩坑

1. 图床配置

图床可以使用PicGo加Github的方式，不过这种方式生成的图片链接可能无法直接访问，可以通过修改hosts解决，先通过DNS工具获取到指定域名的ip，再将ip和域名添加到hosts中就可以了。

PicGo+Github配置的方式可以参考下面链接：

https://www.jianshu.com/p/d51258ef5484

2. rzsz安装

参考这个链接可以通过brew的方式下载多种工具，包括lrzsz

但是下载后还不能直接使用，会出现终端直接卡死的现象，需要给iterm2配置相应的Triggers。

配置

在/usr/local/bin目录下新建两个文件，并添加上内容

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
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66

vim iterm2-recv-zmodem.sh
vim iterm2-send-zmodem.sh
## contents in iterm2-recv-zmodem.sh
#!/bin/bash
# Author: Matt Mastracci (matthew@mastracci.com)
# AppleScript from http://stackoverflow.com/questions/4309087/cancel-button-on-osascript-in-a-bash-script
# licensed under cc-wiki with attribution required 
# Remainder of script public domain
 
osascript -e 'tell application "iTerm2" to version' > /dev/null 2>&1 && NAME=iTerm2 || NAME=iTerm
if [[ $NAME = "iTerm" ]]; then
    FILE=`osascript -e 'tell application "iTerm" to activate' -e 'tell application "iTerm" to set thefile to choose folder with prompt "Choose a folder to place received files in"' -e "do shell script (\"echo \"&(quoted form of POSIX path of thefile as Unicode text)&\"\")"`
else
    FILE=`osascript -e 'tell application "iTerm2" to activate' -e 'tell application "iTerm2" to set thefile to choose folder with prompt "Choose a folder to place received files in"' -e "do shell script (\"echo \"&(quoted form of POSIX path of thefile as Unicode text)&\"\")"`
fi
 
if [[ $FILE = "" ]]; then
    echo Cancelled.
    # Send ZModem cancel
    echo -e \\x18\\x18\\x18\\x18\\x18
    sleep 1
    echo
    echo \# Cancelled transfer
else
    cd "$FILE"
    /usr/local/bin/rz -E -e -b
    sleep 1
    echo
    echo
    echo \# Sent \-\> $FILE
fi
#------------ 分割线-----------------------
### contents in iterm2-send-zmodem.sh
#!/bin/bash
# Author: Matt Mastracci (matthew@mastracci.com)
# AppleScript from http://stackoverflow.com/questions/4309087/cancel-button-on-osascript-in-a-bash-script
# licensed under cc-wiki with attribution required 
# Remainder of script public domain
 
osascript -e 'tell application "iTerm2" to version' > /dev/null 2>&1 && NAME=iTerm2 || NAME=iTerm
if [[ $NAME = "iTerm" ]]; then
    FILE=`osascript -e 'tell application "iTerm" to activate' -e 'tell application "iTerm" to set thefile to choose file with prompt "Choose a file to send"' -e "do shell script (\"echo \"&(quoted form of POSIX path of thefile as Unicode text)&\"\")"`
else
    FILE=`osascript -e 'tell application "iTerm2" to activate' -e 'tell application "iTerm2" to set thefile to choose file with prompt "Choose a file to send"' -e "do shell script (\"echo \"&(quoted form of POSIX path of thefile as Unicode text)&\"\")"`
fi
if [[ $FILE = "" ]]; then
    echo Cancelled.
    # Send ZModem cancel
    echo -e \\x18\\x18\\x18\\x18\\x18
    sleep 1
    echo
    echo \# Cancelled transfer
else
    /usr/local/bin/sz "$FILE" -e -b
    sleep 1
    echo
    echo \# Received $FILE
fi
#############################
# 写完后修改权限
chmod 777 iterm2-*

接着为iterm2添加配置，Perference-> Profiles -> Default -> Advanced -> Triggers 的 Edit

内容如下：

1
2
3
4
5
6
7

Regular expression: rz waiting to receive.\*\*B0100
Action: Run Silent Coprocess
Parameters: /usr/local/bin/iterm2-send-zmodem.sh
 
Regular expression: \*\*B00000000000000
Action: Run Silent Coprocess
Parameters: /usr/local/bin/iterm2-recv-zmodem.sh

小结

小tips

下载软件可以使用Folx

sublime破解可以参考这篇

强烈推荐Go2Shell和Easy new file, 新建文件和终端可以非常方便

最后非常推荐知乎大佬的这篇文章，介绍了mac上各种提效小工具，值得一看

https://zhuanlan.zhihu.com/p/121798647

为了配置一个开源库，折腾了好久，还联系了作者，发现它只能在linux系统上运行，无奈只好在linux上配置python+numpy+scipy等一系列开发环境，这里记录下遇到的坑。。。

1. 安装成功了numpy，却无法调用，ImportError
   使用sudo pip install numpy成功安装了numpy,并且使用pip list能查看到确实存在numpy包，但是import numpy就会报错，我的解决方法如下：
   • find / -name numpy 找到numpy所在的位置，结果发现我安装的numpy出现在了/usr/local/python2.7/lib/dist-packages路径下。
   • rm -rf numpy 删除那个路径下的numpy相关文件
   • sudo pip install numpy -t ../site-packages/ 重新安装numpy到site-packages路径下
   • 这样再import numpy就不会报importError了
2. numpy调用后提示undefined symbol: PyUnicodeUCS2_FromUnicode
   • 这种情况只能重新编译python成4个unicode字节，切换至下载解压好的python目录
   • sudo ./configure –enable-shared –enable-unicode=ucs4
   • 接着 sudo make install 安装
   • 安装成功后，再次调用numpy就不会有问题了。
3. python安装matplotlib错误
   • 一开始遇到的错误是 matplotlib fatal error:Python.h:没有那个文件或目录。解决方法是需要先安装好Python的静态库和头文件，使用apt-get即可：sudo apt-get install python-dev
   • 之后在import时遇到了错误是 No module named bz2，详细情况可以参考
     here,我采用了其中的先安装libbz2-dev， sudo apt-get install libbz2-dev，再重新编译python，就可以了。

待续。。。。

什么样的聚类效果好？

聚类结果的簇内相似度高，且簇间相似度低

聚类性能度量

外部指标：结果与某个参考模型作比较，如Jaccard系数，FM指数，Rand指数，
内部指标：直接考察聚类结果，如DB指数，DI指数

计算距离

闵可夫斯基距离和VDM距离结合，可以计算有序属性和无序属性

sklearn聚类

• 参考：
  • sklearn聚类算法详解
  • scikit-learn中的无监督聚类算法
• scikit-learn主要由分类、回归、聚类和降维四大部分组成，其中分类和回归属于有监督学习范畴，聚类属于无监督学习范畴，降维适用于有监督学习和无监督学习。scikit-learn的结构示意图如下所示：
• 
• scikit-learn中的聚类算法主要有：
  • K-Means(cluster.KMeans)
  • AP聚类（cluster.AffinityPropagation）
  • 均值漂移（cluster.MeanShift）
  • 层次聚类（cluster.AgglomerativeClustering）
  • DBSCAN（cluster.DBSCAN）
  • BRICH（cluster.Brich）
  • 谱聚类（cluster.Spectral.Clustering）
  • 高斯混合模型（GMM）∈期望最大化（EM）算法（mixture.GaussianMixture）

K-Means

1.1 算法描述

1. 随机选择k个中心
2. 遍历所有样本，把样本划分到距离最近的一个中心
3. 划分之后就有K个簇，计算每个簇的平均值作为新的质心
4. 重复步骤2，直到达到停止条件

• 停止条件：
  • 聚类中心不再发生变化；所有的距离最小；迭代次数达到设定值，
• 代价函数：误差平方和

1.2 算法优缺点

优点：

• 算法容易理解，聚类效果不错
• 具有出色的速度
• 当簇近似高斯分布时，效果比较好

缺点：

• 需要自己确定K值,k值的选定是比较难确定
• 对初始中心点敏感
• 不适合发现非凸形状的簇或者大小差别较大的簇
• 特殊值/离群值对模型的影响比较大
• 从数据先验的角度来说，在 Kmeans 中,我们假设各个 cluster 的先验概率是一样的,但是各个 cluster 的数据量可能是不均匀的。举个例子,cluster A 中包含了10000个样本,cluster B 中只包含了100个。那么对于一个新的样本,在不考虑其与A cluster、 B cluster 相似度的情况,其属于 cluster A 的概率肯定是要大于 cluster B的。

1.3 效果评价

聚类结果的簇内相似度高，且簇间相似度低

常见方法有轮廓系数Silhouette Coefficient和Calinski-Harabasz Index(CH指标，越大越好)

Silhouette Coefficient：

$$s(i)=\frac{b(i)-a(i)}{max(a(i),b(i))}$$

其中a(i)是样本$i$到同类所有样本的平均距离，b(i)是到其他某类所有样本的平均距离

• si接近1，则说明样本i聚类合理；
• si接近-1，则说明样本i更应该分类到另外的簇；
• 若si 近似为0，则说明样本i在两个簇的边界上。

Calinski-Harabasz Index

类别内部数据的协方差越小越好，类别之间的协方差越大越好，这样的Calinski-Harabasz分数会高。实例代码：

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
31
32
33
34
35
36
37
38
39
40

"""
下面的方法是用kmeans方法进行聚类，用calinski_harabaz_score方法评价聚类效果的好坏
大概是类间距除以类内距，因此这个值越大越好
"""
import matplotlib.pyplot as plt
from sklearn.datasets import make_blobs
from sklearn.cluster import KMeans
from sklearn import metrics
"""
下面是生成一些样本数据
X为样本特征，Y为样本簇类别， 共1000个样本，每个样本2个特征，共4个簇，簇中心在[-1,-1], [0,0],[1,1], [2,2]，
簇方差分别为[0.4, 0.5, 0.2]
"""
X, y = make_blobs(n_samples=500, n_features=2, centers=[[2,3], [3,0], [1,1]], cluster_std=[0.4, 0.5, 0.2],
                  random_state =9)
"""
首先画出生成的样本数据的分布
"""
plt.scatter(X[:, 0], X[:, 1], marker='o')
plt.show()
"""
下面看不同的k值下的聚类效果
"""
score_all=[]
list1=range(2,6)
#其中i不能为0，也不能为1
for i in range(2,6):
    y_pred = KMeans(n_clusters=i, random_state=9).fit_predict(X)
    #画出结果的散点图
    plt.scatter(X[:, 0], X[:, 1], c=y_pred)
    plt.show()
    score=metrics.calinski_harabasz_score(X, y_pred)
    score_all.append(score)
    print(score)
"""
画出不同k值对应的聚类效果
"""
plt.plt(list1,score_all)
plt.show()

python实现KMeans

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
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68

import pandas as pd
import numpy as np
from sklearn.preprocessing import LabelEncoder,OneHotEncoder
def random_k_sample(data, k):
    """
    随机选择K个样本作为初始均值向量
    """
    n = np.shape(data)[1] # n个特征
    m = np.shape(data)[0]
    centroids = np.zeros((k, n)) # k个样本
    temp = random.sample(range(m), k)
    for i in range(k):
        centroids[i] = data[temp[i]]
    
    return centroids
## 数据加载过程省略
my_data = data.iloc[:, 0:-1]
my_data = my_data.values
def calc_dist(vec1, vec2):
    """
    计算欧式距离
    """
    return np.sqrt(np.sum(np.power(vec1 - vec2, 2)))
m = np.shape(my_data)[0]
n = np.shape(my_data)[1]
k = 3
centroids = random_k_sample(my_data, k)
# 每个样本与选出来的样本向量计算距离，距离谁近就归为哪一类
result = np.zeros((m, 2)) # 存放样本类别，和到质心的距离
# 控制均值向量是否更新
changed = True
while (changed):
    for i in range(m):
        min_value = np.inf # 最小距离
        min_label = -1 # 类别
        for j in range(k):
            dist = calc_dist(my_data[i], centroids[j])
            if dist < min_value:
                min_value = dist
                min_label = j
        
        result[i, :] = min_value, min_label
        print('iteration %d, %s' % (i, result[i, :]))
    
    is_update = False
    for j in range(k):
        # 计算新的均值向量
        # 对每一类的特征列求平均值
        temp = np.mean(my_data[(result[:, 1] == j)], axis=0)
        
#         print(temp)
#         print(centroids[j])
        # 如果均值向量更新了，重新迭代
        if (centroids[j] != temp).any():
            centroids[j] = temp
            print('update')
            is_update = True
    
    if is_update:
        changed = True
    else:
        changed = False
data['label'] = result[:, 1]

LVQ算法

学习向量量化，随机选择有标记训练样本，找出距离最近的原型向量，根据两者的类别标记是否相同来对原型向量进行相应的更新（靠拢或者远离）。

高斯混合聚类

初始化模型参数，计算各混合分布的后验概率，重新计算新均值向量，新协方差矩阵，新混合系数，不断迭代。

密度聚类算法

DBSCAN

基于密度的空间聚类方法

簇：由密度可达关系导出的最大的密度相连样本集合。
DBSCAN的聚类是一个不断生长的过程。先找到一个核心对象，从整个核心对象出发，找出它的直接密度可达的对象，再从这些对象出发，寻找它们直接密度可达的对象，一直重复这个过程，直至最后没有可寻找的对象了，那么一个簇的更新就完成了。也可以认为，簇是所有密度可达的点的集合。

两个参数：

• • Eps邻域半径(epsilon,小量，小的值）
• • MinPts(minimum number of points required to form a cluster)定义核心点时的阈值。

几个概念：

• $\epsilon$ 邻域: 对于样本$x_j$，包含D中与$x_j$样本距离不大于$\epsilon$的样本

• 核心对象：对于任一样本点，如果其 $\epsilon$ 邻域内至少包含MinPts个样本点，那么这个样本点就是核心对象。（一个点）

• 直接密度可达：如果一个样本点p处于一个核心对象q的Eps邻域内，则称该样本点p从对象q出发时是直接密度可达的。
• 密度相连：对于样本点p和q，如果存在核心对象m,使得p、p均由m直接密度可达，则称p和q密度相连。

优点：

• 不需要指定cluster的数目
• 聚类的形状可以是任意的
• 能找出数据中的噪音，对噪音不敏感
• 算法应用参数少，只需要两个
• 聚类结果几乎不依赖于节点的遍历顺序

缺点：

• 如果样本集较大时，聚类收敛时间较长，此时可以对搜索最近邻时建立的KD树或者球树进行规模限制来改进。
• DBSCAN算法的聚类效果依赖于距离公式的选取，实际中常用的距离是欧几里得距离，由于‘维数灾难’，距离的度量标准已变得不再重要。（分类器的性能随着特征数量的增加而不断提升，但过了某一值后，性能不升反而下降，这种现象称为维数灾难。对于维度灾难的理解：维度灾难的理解）
• 不适合数据集中密度差异很大的情形，因为这种情形，参数Eps,MinPts不好选择。（个人理解，如果是密度大的，你选一个小的邻域半径就可以把这些数据点聚类，但对于那些密度小的数据点，你设置的小的邻域半径，并不能把密度小的这些点给全部聚类。）

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
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70

from sklearn.cluster import DBSCAN
from sklearn.datasets import make_blobs
import numpy as np
import matplotlib.pyplot as plt
from itertools import cycle
from sklearn.preprocessing import StandardScaler
# 产生随机数据的中心
centers = [[1, 1], [1, -1], [1, -1]]
n_samples= 500
X, label_true = make_blobs(n_samples=n_samples, centers=centers,
                           cluster_std=0.4, random_state=0)
# 设置密度聚类, 默认是欧式距离
model = DBSCAN(eps=0.3, min_samples=10)
# 自定义函数
#DB = DBSCAN(eps=400,min_samples=min_samples_num, metric=lambda a, b: haversine(a,b)).fit(X)
model.fit(X)
core_samples_mask = np.zeros_like(label_true, dtype=np.bool)
'''
   这里是关键点(针对这行代码：xy = X[class_member_mask & ~core_samples_mask])：
   db.core_sample_indices_  表示的是某个点在寻找核心点集合的过程中暂时被标为噪声点的点(即周围点
   小于min_samples)，并不是最终的噪声点。在对核心点进行联通的过程中，这部分点会被进行重新归类(即标签
   并不会是表示噪声点的-1)，也可也这样理解，这些点不适合做核心点，但是会被包含在某个核心点的范围之内
'''
core_samples_mask[model.core_sample_indices_] = True
##每个数据的分类
label = model.labels_
##分类个数：lables中包含-1，表示噪声点
n_clusters_ =len(np.unique(label)) - (1 if -1 in label else 0)
##绘图
unique_labels = set(label)
'''
   1)np.linspace 返回[0,1]之间的len(unique_labels) 个数
   2)plt.cm 一个颜色映射模块
   3)生成的每个colors包含4个值，分别是rgba
   4)其实这行代码的意思就是生成4个可以和光谱对应的颜色值
'''
colors = plt.cm.Spectral(np.linspace(0, 1, len(unique_labels)))
plt.figure(1)
plt.clf()
for k, col in zip(unique_labels, colors):
    ##-1表示噪声点,这里的k表示黑色
    if k == -1:
        col = 'k'
    ##生成一个True、False数组，lables == k 的设置成True
    class_member_mask = (label == k)
    ##两个数组做&运算，找出即是核心点又等于分类k的值  markeredgecolor='k',
    xy = X[class_member_mask & core_samples_mask]
    plt.plot(xy[:, 0], xy[:, 1], 'o', c=col,markersize=14)
    '''
       1)~优先级最高，按位对core_samples_mask 求反，求出的是噪音点的位置
       2)& 于运算之后，求出虽然刚开始是噪音点的位置，但是重新归类却属于k的点
       3)对核心分类之后进行的扩展
    '''
    xy = X[class_member_mask & ~core_samples_mask]
    plt.plot(xy[:, 0], xy[:, 1], 'o', c=col, markersize=6)
plt.title('Estimated number of clusters: %d' % n_clusters_)
plt.show()