获取ROOT：

基本上我的操作步骤如第一篇文章所述，部分细节需要注意，不得不说，国外的论坛真的大多简单明了还不收费，国内很多都是一通抄袭,而且步驟非常不完整。本文其實大部分内容都是引用自其他内容,但是做了較爲完整的整合引用,以及細節説明.

1. 获取Boot Image镜像

   如链接[3]，源文中未给出具体链接，这里一定要选择与手机一致的版本号，

Settings > About phone > Build number.

将文件解压，取出压缩包中的boot.img 文件，将文件拷贝到手机目录中（建议选择Download路径，不然后面找起来比较麻烦）

2. Magisk Manager

   面具的下载地址有很多了，如果能访问官网，我建议是直接从连接[4]中下载最新版本，安装完毕后选择install> select and patch a file > 选择boot.img文件，选择完毕之后，它将会给你一个magisk_patched.img 文件，记得把这个文件再拷贝回去电脑上留着。

3. 打开OEM锁

   去设置里将选择>About phone. >多次點擊Build number > 返回上級頁面 ,選擇System > Developer Options. > 打開OEM unlocking

4. 安裝ADB

   ADB的安裝比較簡單,就是下載一個軟件包,免安裝,如[5].需要注意的是,一定要使用CMD打開命令行,不要使用powershell.

5. Unlock Bootloader

   解鎖BL,需要關閉手機,然後按下電源按鍵以及音量減(注意是音量-).另外在此之前還需要安裝驅動.驱动程序文件如[6],安裝驅動方法如[7].

   安装好驱动后,在手机打开USB调试模式

   输入命令:

   adb devices

   可检查是否正常连接.

   进入BL页面后,可以通过命令

   fastboot devices

   检查是否有正常连接.

   进入BL页面之后,电脑连接手机,打开命令行输入

   fastboot flashing unlock

   即可解锁

   解锁完毕之后,再将我们拷贝出来的magisk_patched.img 文件刷入手机

   fastboot flash boot path/to/magisk_patched.img

   其中path/to 为本地文件所在的路径.

至此ROOT已经完毕，获取到ROOT之后，手机开机会有一个风险提示，忽略即可。

另外面具APP可能无法正常使用，需要重新安装。

解锁Motion Sense：

解锁Motion Sense需要安装EdXposed,如链接[8]，在Modules中搜索enableSoliOnPixel4,如[13],安装即可。

也可以通过命令行方式修改，如链接[11]，但是据说重启会失效？

1

adb shell setprop pixel.oslo.allowed_override 1

修改本地网络检查方式：

参考链接[10],将网络检查的地址修改为google中国的地址

删除默认地址

adb shell settings delete global captive_portal_https_url
adb shell settings delete global captive_portal_http_url

改用新地址

adb shell settings put global captive_portal_http_url http://captive.v2ex.co/generate_204
adb shell settings put global captive_portal_https_url https://captive.v2ex.co/generate_204

ref:

[1]https://www.xda-developers.com/google-pixel-4-root-magisk/ 获取root

[2]https://blog.csdn.net/asdrt12589wto1/article/details/115965281 网络受限

[3]https://developers.google.com/android/ota 镜像下载

[4]https://magiskmanager.co/apk/ 面具

[5]https://www.xda-developers.com/install-adb-windows-macos-linux/ 安裝ADB

[6]https://developer.android.com/studio/run/win-usb?hl=zh-cn 驱动

[7]https://blog.csdn.net/qz2014728/article/details/101760398 安裝驅動

[8]https://edxposed.com/edxposed-install 安装Edxposed

[9]https://www.didgeridoohan.com/magisk/ManagerIssues 面具问题

[10]https://blog.csdn.net/asdrt12589wto1/article/details/115965281 网络校验修正

[11]https://forum.xda-developers.com/t/magisk-tasker-release-motion-sense-soli-oslo-mod.3993877/#post-80729593 命令行启用motion sense

[12]https://www.xda-developers.com/enable-pixel-4-motion-sense-gestures/ 启用motion sense

[13]https://forum.xda-developers.com/t/success-enable-soli-on-china.3994917/ enableSoliOnPixel4

一个简单的类：

1
2
3
4
5

class Restaturant(object):
bankrupt = False
    def open_branch(self):
        if not self.bankrupt:
            print("branch opened")

首先我们从非专业的角度解释这段代码。首先我们创建一个类 Restaurant。然后我们生命它的一个属性 bankrupt 为 false。然后我们定义一个函数open_branch ，仅当 bankrupt 为 false 的时候触发打印功能，这意味着Restautant 还有钱。

创建一个 resturant：

现在，我们来创建一个Restaurant类的对象，让我们创建一个resturant：

1

x = Restaurant()

现在 x 是一个Restaurant，并且具有bankrupt 属性以及一个open_branch 函数。现在我们可以通过以下代码访问这个bankrupt属性：

1

x.bankrupt

以下命令具有相同的效果：

1

Restaurant().bankrupt

现在你可以看到self 指的是绑定的变量或者对象。在第一个例子中，由于我们已经将Restaurant 类赋值到x，所以self 就是x，然而第二个例子中就是Restaurant() 。现在我们有另一个Restaurant y，self 将会自动访问y的bankrupt而不是x的。例如：

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

>> x = Restaurant()
>> x.bankrupt
>> x.open_branch()
False
branch opened

>> y = Restaurant()
>> y.bankrupt = True
>> y.bankrupt
>> y.open_branch()
True


>> x.bankrupt
>> x.open_branch()
False
branch opened

在上面的例子中，当修改了x.bankrupt 之后， x.open_branch()也无法正常打印。简单的说，self就是类自身，通过self.xxx可以引用当前方法所在类的属性和方法。而在使用某个方法的时候并不需要为self参数传递值。

每一个类的第一个方法（包括init），总是一个引用当前类的实例。更通俗的说，这个参数总是被成为self。在init 方法中，self 指的是新创建的对象；在其他类的方法中，它代表实例的方法被调用。下面的例子有相同的效果：

1
2
3
4
5

class Restaurant(object):
    bankrupt = False
    def open_branch(this):
        if not this.bankrupt:
            print("branch opened")

然而 self 在python 中并不是一个保留关键字，仅仅是一个普遍共识。许多人说为什么我们必须要写self？为什么不能像java一样自动设置？一些人也提交了PEP（改进建议）并建议移除这个self的声明。然而 GuidoVan Rossum 写了一个bolg解释为什么不得不声明self。

引用：

[1] https://pythontips.com/2013/08/07/the-self-variable-in-python-explained/
[2] http://neopythonic.blogspot.com/2008/10/why-explicit-self-has-to-stay.html

问题描述

假设有 1 元，3 元，5 元的硬币若干（无限），现在需要凑出 11 元，问如何组合才能使硬币的数量最少？

输入硬币种类数量为number，需要凑出的金钱为money

接下来number列，输入所有的硬币种类money_list[]

问题分析

我们从凑出1元开始，依次递进，最终得到凑出11元的结果。

1. 假设res_list[i] 为凑出i元所需要的硬币数量

2. 我们生成状态转移方程：

   res_list[i] =min_j=1…number[res_list[i-coin_j] + 1)]，其中coin_j为所有硬币种类硬币序列

   即 当前凑出i的 最优解数量是凑出 i-coin_j 的最优解 +1，且+1所代表的硬币是coin_j。

3. res_list[0] 必定是0，res_list[1] = min_{j = 1… number}[res_list[1-coin_j] +1]

4. 每次得到res_list[i]的值之后，都将当前的res_order[i-coin_j]和coin_j保存到res_order[i]中，作为硬币序列。

算法代码

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

# 输入硬币种类数量和需要凑的金钱
number, money = input().split(' ')
# 金钱种类列表，存放所有类型的硬币
money_lists = []
# 输入所有硬币种类的面值
for i in range(int(number)):
    money_lists.append(int(input()))

res_list = [0 for i in range(int(money)+1)]  # 保存结果列表，每个数组都是该情况最小的种类数量
res_order = [[0 for j in range(0)] for i in range(int(money)+1)]  # 保存结果序列，其中每一个数组都保存了一个该情况的最小硬币序列
for i in range(1, int(money)+1):  # 遍历所需要凑的金额
    current_coin = -1
    min_res = -1
    for j in money_lists:  # 遍历硬币面值
        if i >= j:  # 确定不会超出界限，即当前需要的硬币总额不小于当前硬币面额
            if min_res == -1:
                min_res = res_list[i-j]+1
                current_coin = j
            elif res_list[i-j]+1 < min_res:
                min_res = res_list[i-j]+1
                current_coin = j
    res_list[i] = min_res  # 将最小的种类组合个数复制给当前res_lists
    for k in res_order[i-current_coin]:  # 保存当前硬币序列到列表order。
        # print(res_order[i-current_coin])
        # print(i)
        if k != 0:
            res_order[i].append(k)
    if current_coin != 0:
        res_order[i].append(current_coin)

# print(res_list)
print(res_order)

算法代码点击 这里

引用：

https://www.cnblogs.com/snowInPluto/p/5992846.html

最近刷到一道题，在01背包问题中有稍微改变。

题中不仅要求输出最大概率之和，还要求输出楼盘ID。

动态规划问题

例如输入序列为：

5 10
2 0.2
3 0.3
4 0.44
5 0.55
6 0.6

贪心算法：

第一种解法是贪心算法

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

def greedy():
    number, fund = input().split(' ')
    fund = int(fund)
    array = []
    max_prob = []
    max_value = 0
    for i in range(int(number)):  # 输入锁定金额和概率
        value, prob = input().split(' ')
        current_id = i+1
        array.append([current_id, int(value), float(prob), float(prob)/float(value)])
    print(array)
    # 第四位排序
    array.sort(key=take_four, reverse=True)
    print(array)
    for i in array:  # 选中最佳可能的资金
        max_value += i[1]
        if max_value < fund:
            max_prob.append([i[0], i[2]])
    print('max_prob:', max_prob)
    max_prob_value = 0
    for i in max_prob:
        max_prob_value = i[1] + max_prob_value
    print(max_prob_value, [x[0] for x in max_prob])

我们可以得到结果

0.99 [4, 3]

显然这不是我们想要的结果，因为最优解应该为1，2，4 = 1.05才对。

动态规划

寻找最大概率值

使用动态规划的方法解决该问题需要对问题建立转移方程：

1. 输入楼盘数量为number，总资金为fund

2. 输入楼盘的数据raw_data.

3. 定义子问题P(i, v)为在前i个楼盘中挑选总价值不超过v的楼盘，并且每个楼盘只能选择一次，使得最终抽中的总概率最大。我们此时的最优解记作max_prob(i, w)，其中1<=i<=number,1<=w<=fund。

4. 当我们考虑第i个楼盘的时候：

   如果不选择，则总资金容量不变，改为问题P(i-1, w)

   如果选择这个楼盘，则总资金剩余容量变小，改问题为P(i-1, w-wi)

5. 最优解的问题就是比较3中两个方案哪一个是最佳的：

   max_prob(i,w) = max{max_prob(i-1,w),max_prob(i-1,w-wi)+valuei}

例如输入序列为：

5 10
2 0.2
3 0.3
4 0.44
5 0.55
6 0.6

假设我们一共有10W金钱，楼盘价值分别为2，3，4，5，6。楼盘概率分别为0.2，0.3，0.44，0.55，0.6。

那么我们通过转移方程可以推算出以下表格max_prob：

推算过程:

1. 建立一个表格，大小为number×fund。

2. 逐层遍历，按列遍历。

   1. 当资金为1的时候，没有任何房产可以购买。

   2. 当资金为2的时候，可以购买房产1。

   3. 当资金为3的时候，可以购买房产1，但是当遍历到（2，3）的时候，对比

      max{max_prob(i-1,w),max_prob(i-1,w-wi)+valuei}

      其中max_prob(i-1,w) 代表i-1行w列。

      其中max_prob(i-1,w)为0.2，max_prob(i-1,w-wi)+valuei 为0.2-0.2 + 0.3 = 0.3

   4. 经过逐次的遍历，得到最终整个矩阵数据。

算法代码：

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

def dynasty():
    # ----------------输入数据----------------------
    number, fund = input().split(' ')
    fund = int(fund)
    number = int(number)
    max_prob = [[0 for col in range(fund+1)] for row in range(number+1)]
    raw_data = []
    for i in range(int(number)):  # 输入锁定金额和概率
        value, prob = input().split(' ')
        current_id = i+1
        raw_data.append([current_id, int(value), float(prob), float(prob)/float(value)])
    # ---------------计算概率分布矩阵-------------------
    all_max = 0
    for i in range(1, number+1):  # 遍历所有的房价,number为房产个数
        for j in range(1, fund+1):  # 遍历所有总金额,
            # print(i, j, raw_data[i-1][1])
            if j < raw_data[i-1][1]:  # 假定的总金额小于当前房产的价格
                max_prob[i][j] = max_prob[i-1][j]  # 概率等于之前的
            else:
                max_prob[i][j] = max(max_prob[i-1][j], (max_prob[i-1][j-raw_data[i-1][1]] + raw_data[i-1][2]))
                if max_prob[i][j] > all_max:  # 记录概率最大值
                    all_max = max_prob[i][j]
   
# ----------------打印概率分布矩阵---------------
    print('概率分布矩阵:\n', max_prob)
    print('all_max_prob:', all_max)

计算楼盘的序列

1. 定义指针（i,j）倒序遍历表格

2. 从末尾开始遍历,寻找按顺序排列第一次出现all_max节点,将all_max修改为all_max-raw_data[i][prob]

3. 当找到第一个星号1.05后移动指针位置到（i-1,j-1）,检测当前值是否为第一次出现的all_max,如果是，标记为星，并重复2步骤，直到遍历到（0，0）

4. 输出所有标记星所在的行即为楼盘序列。

   

算法代码：

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

# ----------------从表中推出楼盘列表--------------
id_list = []
# id_list.append(max_id)
# 反向查找关键节点
j = fund  # 定义列位置
i = number  # 定义行位置
while i != 0 and j != 0:  # 从max_prob表右下位置开始，逆序遍历
    # print('all_max:', all_max)
    print('当前遍历的节点i,j,prob:', i, j, max_prob[i][j])
    # print('value:', int(max_prob[i][j]))
    # print('value_(i,j-1):', int(max_prob[i][j-1]))
    # 如果同行上一列的的概率值仍然为最大，则切换到上一列
    if max_prob[i][j-1] == all_max:
        # print('j = j-1')
        j = j-1
    # 如果同列上一行的的概率值仍然为最大，则切换到上一行
    elif max_prob[i - 1][j] == all_max:
        # print('i = i-1')
        i = i-1
    # 处于拐点，可能是一个关键点。
    else:
        # print('test', int(max_prob[i][j]), int(all_max - raw_data[i-1][2]))
        # 如果当前概率等于最大的概率，则是关键点
        if max_prob[i][j] == all_max:
            id_list.append(raw_data[i-1][0])  # 保存当前楼盘的id
            all_max = all_max - raw_data[i-1][2]  # 转换当前最大概率，寻找下一个关键节点
            print('----当前楼盘是关键点之一：', i, '下一个节点prob为：', all_max)
        i = i-1
        j = j-1
print(id_list)

算法源码点击 这里

引用：

https://blog.csdn.net/huanghaocs/article/details/77920358

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

说到QQ游戏，给人的感觉像是回到了N年前一样,现在连小学生都不会玩了吧。

有一天发现QQ游戏有一个栏目-小比赛，使用小比赛中赢得的金豆可以兑换腾讯服务以及腾讯视频VIP，于是就选择了游戏“打手掌”试一试，玩了几局之后发现一个很容易获胜的规律分享给大家。

当对方打你的时候如何闪避

一个小技巧就是手持续按着“闪避”按钮，一旦看到对方伸手来打，就立即松开按钮。这样做相比较看到了再去点击闪避要更容易躲过打击。

如何高效的打中对方

当开始打击对方的时候：

1. 将右手指按在攻击按键上不要松开（注意手要稳一些，不要在按键上滑动，否则容易失去触点）。
2. 持续点击假动作并观察对方动态。
3. 一旦发现对方有收回迹象，立即松开攻击按键，手掌会迅速打击过去，几乎90%的概率可以打中。

收益

打手掌一次可以收益180个金豆，一般的按照以上方法可以有100%的胜率，平局每一次（三局）大概需要2分钟。每天收益上限为2000金豆，大概就是30分钟以内可以达到上限收益。 持续5天即可兑换超级QQ会员一个月/腾讯视频VIP一个月/腾讯黄钻两个月 （腾讯视频VIP现在每个月只能兑换一次/7天，2400金豆，而且每天一个上午就兑换完了，不知道还有没有9000金豆/一个月的兑换方法）。

当然游戏还是需要放松时娱乐一下就好。如果把它当成一件任务来完成也是蛮累的。

最后，不知道这个玩法算不算bug，说不定哪一天就被封了呢？有缘看到的网友就不要转载传播啦233（并且大家都知道后这个游戏也就不是那么容易获胜了）。

画图工具：https://www.draw.io/

画表格工具：https://tablesgenerator.com/

在线写文档工具：https://www.overleaf.com

将数学公式转换为Latex

1. 使用MathType 编辑数学公式

   

2. 选项-剪切和复制选项

   

3. 选择转换为latex

   

4. 复制到notepad中即可看到latex格式的公式

   \[E{\rm{ = mc}}\]

表格全文居中

图像排列

文献引用

整体流程

引用文献的article 和//

1，锁定部分变量（网络层），只finetune另一部分变量(网络层)

首先重置默认图,防止出现意外错误

1

tf.reset_default_graph()  # 重置默认图。

定义网络操作pipeline,其中network为使用slim-api定义的一些列卷积操作

1
2
3
4
5

in_image = tf.placeholder(tf.float32, [None, None, None, 4])
gt_image = tf.placeholder(tf.float32, [None, None, None, 3])
out_image = network(in_image)  # 定义pipeline
G_loss = tf.reduce_mean(tf.abs(out_image - gt_image))  # 定义损失函数
lr = tf.placeholder(tf.float32)  # 定义学习率

获取所有的网络参数(即定义网络层的scope=””)

1

t_vars = tf.trainable_variables()  # 获取所有的变量

分别获取需要保持不变的变量和需要finetune的变量,scope中包含g_add的为附加finetune层.

1
2

g_vars = [var for var in t_vars if 'g_add' in var.name]  # 附加的finetune网络层
var_list = [var for var in t_vars if 'g_conv' in var.name]  # 不需要改变的网络层

生成train_op,使用var_list=g_vars 设置仅需要finetune的部分

1

G_opt = tf.train.AdamOptimizer(learning_rate=lr).minimize(G_loss, var_list=g_vars)  # 只训练g_vars部分

以上,其他部分按照正常操作即可以只训练g_vars部分,而不改变vart_list部分

2，加载部分默认网络层参数,而不改变其他网络层的参数

首先定义variables_to_restore,其中exclude=["g_add"] 为不需要恢复的变量,也可以使用include=["g_conv"] 来定义仅需要恢复的变量.[12] [14]

1

variables_to_restore = slim.get_variables_to_restore(exclude=["g_add"])  # 一定要双引号,否则仅exclude 'g_add'一个层.

建立一个re_saver来从已有的模型中恢复g_conv系列参数到网络中.

1

re_saver = tf.train.Saver(variables_to_restore)  # 建立一个saver 用来保存需要恢复的模型变量

再建立一个saver,用来训练的时候保存整个模型的ckpt

1

saver = tf.train.Saver()  # 建立一个模型，用来保存所有的模型变量

将外置模型参数加载到将要训练的模型sess中,并且初始化其余未初始化的参数,训练以及保存模型.

1
2
3
4
5
6
7
8
9

with tf.Session() as sess:
    model_path = './model.ckpt'  # 后缀名称仅需要写ckpt即可,后面的00001-00000不必添加
    re_saver.restore(sess=sess, save_path=model_path)  # 恢复模型的参数到新的模型
    un_init = tf.variables_initializer(get_uninitialized_variables(sess))  # 获取没有初始化(通过已有model加载)的变量 
    sess.run(un_init)  # 对没有初始化的变量进行初始化并训练.
    for epoch in range(lastepoch, 4001):
    _, G_current, output = sess.run([G_opt, G_loss, out_image],
                                        feed_dict={in_image: input_patch, gt_image: gt_patch, lr: learning_rate})  # 执行训练
    saver.save(sess, checkpoint_dir + 'model.ckpt')  # 使用saver.save保存训练模型

总结

​ 网上查的资料大多大同小异,但是有一点都未曾提及,就是训练中保存变量的时候不应该用恢复网络参数所使用的saver来保存全部的参数.否则将只保存原始加载的那部分参数.而新finetune 的layer将无法保存.导致再测试的时候出现找不到某些层的bug

[TensorFlow: NotFoundError: Key not found in checkpoint]

引用：

[1] http://www.tensorfly.cn/tfdoc/how_tos/variables.html

[2] https://blog.csdn.net/wjc1182511338/article/details/82112181 获得未初始化的变量

[3] https://blog.csdn.net/mr_muli/article/details/80868826

[4] https://blog.csdn.net/ArtistA/article/details/52860050

[5] https://zhuanlan.zhihu.com/p/42183653

[6] https://www.quora.com/Is-it-possible-to-only-train-the-final-layer-of-a-Neural-Net-in-TensorFlow-that-was-already-trained

[7] https://stackoverflow.com/questions/37326002/is-it-possible-to-make-a-trainable-variable-not-trainable

[8] https://stackoverflow.com/questions/45093499/how-to-fine-tune-weights-in-specific-layers-in-tensorflow

[9] https://stackoverflow.com/questions/34001922/failedpreconditionerror-attempting-to-use-uninitialized-in-tensorflow

[10] https://stackoverflow.com/questions/47765595/tensorflow-attempting-to-use-uninitialized-value-beta1-power/47780342

[11] https://blog.csdn.net/u011961856/article/details/76850335

[12] https://blog.csdn.net/abc8350712/article/details/78437250

[13] http://mashangxue123.com/TensorFlow/687648778.html

[14] https://github.com/tensorflow/tensorflow/tree/master/tensorflow/contrib/slim

[15] https://cv-tricks.com/tensorflow-tutorial/save-restore-tensorflow-models-quick-complete-tutorial/?tdsourcetag=s_pctim_aiomsg

[16] https://github.com/cchen156/Learning-to-See-in-the-Dark

https://blog.csdn.net/Strive_For_Future/article/details/82426015

https://blog.csdn.net/HowardWood/article/details/79587487

1:

1
2

summary_op = tf.summary.merge_all()
summary_writer = tf.summary.FileWriter('./mid_result', tf.get_default_graph())

需要添加在sess.run()开始循环迭代之前，不要添加在循环内部，可能会造成多次创建总结数据。

2:

1
2

summary_str = sess.run(summary_op, feed_dict={in_image: input_full})
summary_writer.add_summary(summary_str, 1)

需要添加在sess.run()之后。

3：

show_feature_map_direct(layer=conv10, layer_name="conv10", num_or_size_splits=12, axis=3, max_outputs=3)

在每一个想要查看的中间层代码后，添加如上代码。

layer: 想要输出的层结果，

layer_name:输出层的scope/name,

num_or_size_splits:输出层的层数。

可以放在卷积层后，也可以放在残差层后：

conv10 = slim.conv2d(conv9, 12, [1, 1], rate=1, activation_fn=None, scope='g_conv10')

conv10 = tf.add(conv10, add_result, name='g_add_conv10')

4:

添加显示图函数到代码中供调用：

1
2
3
4
5

def show_feature_map_direct(layer, layer_name, num_or_size_splits, axis, max_outputs):
    split = tf.split(layer, num_or_size_splits=num_or_size_splits, axis=axis)

    for i in range(num_or_size_splits):
        tf.summary.image(layer_name + "-" + str(i), split[i], max_outputs)

5：

运行时，在控制台命令行执行tensorboard命令，将会同时记录日志文件到mid_result文件夹中。

tensorboard --logdir='./mid_result'

浏览器访问http://127.0.0.1:6006 即可看到tensorboard的控制台。

6：

如果为远程服务器，可以从本地命令行新建立ssh链接

ssh -L 16006:127.0.0.1:6006 account@server.address

然后在本地浏览器访问http://127.0.0.1:16006 即可查看tensorboard控制台。

引用：

https://www.tensorflow.org/guide/summaries_and_tensorboard

https://zhuanlan.zhihu.com/p/31865749?from_voters_page=true

https://www.jianshu.com/p/4e8e5f516d84

bayer图像格式

由于人眼对GREEN颜色的感知更为强烈，所以一般raw 格式的图像每个2*2矩阵中，都有两个G分量，一个R以及一个B分量，G分量的排列方式可以有所不同，如下图：

对于转换为RGB格式，一般采取插值的方法，将原始图像中的R/G/B三个分量，插值到附近，分别产生新的三个矩阵，分别为R,G,B。

以下为代码，对于两个G分量采用均值方法优化插值：

1-自己写的函数最终得到图像结果：
放大：

原图：

2-使用sony插件直接查看arw图像的结果：
放大：

原图：

3-使用python rawpy库函数的postprocess 方法默认参数处理：
放大：

原图：

4-使用learning to see in dark 中的postprocess 方法所设置的参数处理：
rgb = raw.postprocess(use_camera_wb=True, half_size=False, no_auto_bright=True, output_bps=16)
放大：

原图：

最终分析结果：
再亮度上：
2>3>4>1

在视觉效果上：
4>2>3>1
在清晰度上：
4=3>2=1
在还原RGB方面，使用参数调节后的rawpy.postprocess方法（use_camera_wb）更好。
造成以上差异的主要因素还是插值方法的不同：
在文章HIGH-QUALITY LINEAR INTERPOLATION FOR DEMOSAICING OF BAYER-PATTERNED COLOR IMAGES 中介绍了更好的插值方法：

引用：
https://letmaik.github.io/rawpy/api/rawpy.Params.html
https://www.microsoft.com/en-us/research/wp-content/uploads/2016/02/Demosaicing_ICASSP04.pdf
http://www.imatest.com/docs/raw/
http://blog.sina.com.cn/s/blog_ebbe6d790101e56e.html
https://blog.csdn.net/peng864534630/article/details/78177211
https://www.cnblogs.com/zhongguo135/p/7755287.html
Learning-to-see-in-draking

1
2
3
4
5
6
7
8

t = tf.constant([[[1, 1, 1], [2, 2, 2]],
                 [[3, 3, 3], [4, 4, 4]],
                 [[5, 5, 5], [6, 6, 6]]])
tf.slice(t, [1, 0, 0], [1, 1, 3])  # [[[3, 3, 3]]]
tf.slice(t, [1, 0, 0], [1, 2, 3])  # [[[3, 3, 3],
                                   #   [4, 4, 4]]]
tf.slice(t, [1, 0, 0], [2, 1, 3])  # [[[3, 3, 3]],
                                   #  [[5, 5, 5]]]

其中后两个参数为 begin和 size。
begin 代表开始位置（每一个维度上从第几个元素开始截取）
size 代表每一个维度从begin位置上开始截取多少个元素

简单的说：
例子：
tf.slice(t, [1, 0, 0], [1, 1, 3]) # [[[3, 3, 3]]]
中的[1, 0, 0] ：
第一个1 代表从行 [[3, 3, 3], [4, 4, 4]] 开始截取。
第二个0 代表从[3, 3, 3] 开始截取
第三个0 代表从元素3 开始截取
中的[1, 1, 3] ：
第一个1 代表截取一个元素即[[3, 3, 3], [4, 4, 4]]
第二个1 代表截取一个元素即[3, 3, 3]
第三个3 代表截取三个元素即3，3，3
最终结果还原原始维度为：[[[3, 3, 3]]]

例子：
tf.slice(t, [1, 0, 0], [2, 1, 3]) # [[[3, 3, 3]], [[5, 5, 5]]]
中的 [1, 0, 0]：
第一个1 代表从行 [[3, 3, 3], [4, 4, 4]] 开始截取。
第二个0 代表从[3, 3, 3] 开始截取
第三个0 代表从元素3 开始截取
中的 [2, 1, 3]：
第一个2 代表截取两个元素即
[[3, 3, 3], [4, 4, 4]],
[[5, 5, 5], [6, 6, 6]]
可以视为:
x = [3, 3, 3], [4, 4, 4]
y = [5, 5, 5], [6, 6, 6]
截取了[x,y]
第二个1代表上面的每一行(每一个元素x or y)截取一个子元素即
[[3, 3, 3]],
[[5, 5, 5]]
这里的每个单元素整体是：
x = [3, 3, 3]
y = [5, 5, 5]
第三个3 代表上面的每一个元素截取三个子元素即
3, 3, 3
5, 5, 5
最终结果还原原始维度为：
[[[3, 3, 3]],[[5, 5, 5]]]

在程序中如果没有确定的维度大小，可以用-1代表终止位置：

1
2
3
4

conv1 = slim.conv2d(input, 32, [3, 3], rate=1, activation_fn=lrelu, scope='g_conv1_1')
conv1 = slim.conv2d(conv1, 32, [3, 3], rate=1, activation_fn=lrelu, scope='g_conv1_2')
slice_1 = tf.slice(conv1, [0, 0, 0, 0], [-1, -1, -1, 16])
slice_2 = tf.slice(conv1, [0, 0, 0, 16], [-1, -1, -1, 16])

concat 的用法就比较简单了，但是要注意坐标的设置：

1
2
3
4

t1 = [[1, 2, 3], [4, 5, 6]]
t2 = [[7, 8, 9], [10, 11, 12]]
tf.concat([t1, t2], 0)  # [[1, 2, 3], [4, 5, 6], [7, 8, 9], [10, 11, 12]]
tf.concat([t1, t2], 1)  # [[1, 2, 3, 7, 8, 9], [4, 5, 6, 10, 11, 12]]

其中第二个参数0 代表以第1维合并，1代表第二维合并…

concat1 = tf.concat([slice_1, slice_2], axis=3)
例如上面的slice_1 与slice_2 的合并需要设置axis=3.

引用：
https://www.tensorflow.org/api_docs/python/tf/slice
https://www.tensorflow.org/api_docs/python/tf/concat

引用：http://cs231n.github.io/convolutional-networks/

计算公式：

假设有一个55的input层
通过kernel=33，padding=1，stride=2 的卷积方式
将会得到33的layer1.（下图为layer1元素对应在input layer中的位置）

其中，每一个元素都是input由33的kernel卷积生成，所以每一个像素的感受野为3

将此层再通过kernel=3 3，padding=1，stride=2的卷积方式卷积。
将会得到2 2的layer2。

此时，每一个元素都是由layer1的3 3个元素通过3 3的卷积核生成。
所以layer2的每个元素感受野为3 3个layer1元素的感受野。
然而layer1元素在原始数据上对应位置的排列如图：

相当于layer2每个元素都感知了3 3个layer1元素，然而layer1每个33在input上的实际感受野为7 7（每个元素都可以感知周边的九个元素。）

那么怎么计算呢，如果规定stride=1的，padding=1，kernel=3的话：每次卷积结果都会是同样尺寸的。
每次卷积都是扩大了一个边界的感受野，就是：(kernel-1)大小的区域。
那么加上约束stride=s之后，每次stride跳动并不会影响到下一层layer在本层的感受野，但是会影响到下下次layer在本层的感受野。
因为当前input-layer1的stride 无论多大，layer1在input上的感受野总是只与卷积核有关。
但是当进行到layer1-layer2,需要求知layer2在input上的感受野，就会受到input-layer1的stride影响，stride越大，所影响input的范围就越大（一般stride不会超过(k-1)/2的，这会造成部分元素无法感知）。
于是
input : r=1
input->layer1 : s=2,k=3,p=1
得到layer1感受野为r=r[input] + (k-1)

layer1->layer2 : s=2,k=3,p=1
得到layer2在input的感受野为r=r[layer1] + (k[1->2]-1) * s[input->layer1]

layer2->layer3 : s=2,k=3,p=1
得到layer3在layer1的感受野为r = r[layer2] + (k[2->3]-1) s[layer1->layer2]
随着stride的累加，造成的感受野增加量也是成倍的扩大。
得到layer3的input感受野为r = r[layer2] + (k[2->3]-1) s[layer1->layer2] * s[input->layer1]

因此得到一般化的公式：
r[current] = r[pre] + (k[pre->current]-1) s[pre->current] s[prepre->pre] … s[input->layer1]
此计算公式与padding是无关的。
其中： (k[pre->current]-1) s[pre->current] s[prepre->pre] … s[input->layer1] 是在上一层感受野基础上多出来的(k-1)边界造成在input上的感受野。

引用：
https://medium.com/mlreview/a-guide-to-receptive-field-arithmetic-for-convolutional-neural-networks-e0f514068807
https://mathematica.stackexchange.com/questions/133927/how-to-compute-the-receptive-field-of-a-neuron
https://stackoverflow.com/questions/35582521/how-to-calculate-receptive-field-size
https://www.reddit.com/r/MachineLearning/comments/6o6cr8/d_how_does_one_calculate_the_receptive_field_of_a/

解决方法：
这道题一眼看去可能是深度/广度优先遍历，这样做时间复杂度会比较高，也可以采用并查集的思想，具体是：
先把所有的大海的点当作坐标存入list-position_array中，
然后将我存入classify_array，
对这个position_array 进行遍历，凡是与calssify_array中元素距离等于1的，都移除存入classify_array中。当所有的距离为1的点都遍历完全之后，classify_array 的元素个数就是所能够达到的面积

这个程序其实还适用于对于目标聚类的算法（可以说算是KNN算法的实现）如下图所示：

对以上目标聚类
下面代码中存入classify_array的时候加入了类别classify_number 元素，如此当一个类别的元素分类完毕之后classify_number +1,继续计算下一个分类。最终会得到带有类别标签的list集合。

classify_array.append((position_array[0], classify_number))
探索大海

解决方法：
此题尚未完全AC，但是在牛客网另一道五子棋试题中稍加修改是可以AC的，当然是由于样例没有完全分析到的原因
牛客网-五子棋

这道题其实看起来是比较容易的，做起来也非麻烦的事情，就是每个点判断上下左右是否成立五子棋的标准。
但是我有一个比较普适性的且容易扩展的方法来解决，就是采用卷积滤波的方式，采用四个5*5的卷积滤波来对棋盘卷积判定，这样的方法对于六子棋，四子棋之类的都可以很容易扩展。
首先构建四个卷积滤波：
array_line = [[0, 0, 0, 0, 0],
​ [0, 0, 0, 0, 0],
​ [1, 1, 1, 1, 1],
​ [0, 0, 0, 0, 0],
​ [0, 0, 0, 0, 0]]
array_long = [[0, 0, 1, 0, 0],
​ [0, 0, 1, 0, 0],
​ [0, 0, 1, 0, 0],
​ [0, 0, 1, 0, 0],
​ [0, 0, 1, 0, 0]]
array_slant1 = [[1, 0, 0, 0, 0],
​ [0, 1, 0, 0, 0],
​ [0, 0, 1, 0, 0],
​ [0, 0, 0, 1, 0],
​ [0, 0, 0, 0, 1]]
array_slant2 = [[0, 0, 0, 0, 1],
​ [0, 0, 0, 1, 0],
​ [0, 0, 1, 0, 0],
​ [0, 1, 0, 0, 0],
​ [1, 0, 0, 0, 0]]
将原始棋盘进行上下左右padding0扩展（由于有可能出现第一行出现五个连续棋子的情况，所有必须要扩展边界。）
对逐个元素卷积判定。记录统计所有五子棋的情况个数。

代码不是很复杂，直接贴上来好了
五子棋

解题方法：
首先po一个很直观的对hilbert的理解：
https://www.bilibili.com/video/av4201747?from=search&seid=12530994814698419444
看完这个视频基本上就对这个曲线有所了解了，解法当然也就显而易见，就是首先构建一个基础的22的hilbert曲线轨迹

由于要求输出结果为顺序，定义一个以上轨迹顺序的矩阵base_box：
[[2 3]
[1 4]]
然后将这个base_box 扩展到44的矩阵中中上面两个22矩阵，
对于下面的连个22 矩阵，左下的矩阵进行逆时针旋转，右下的矩阵进行顺时针旋转。
然后将旋转之后的数字顺序反转一下
将左上22矩阵+4，右上+8，右下+12
就得到了hilbert矩阵
[[ 6 7 10 11]
[ 5 8 9 12]
[ 4 3 14 13]
[ 1 2 15 16]]
最终这个44的矩阵就做好了，下一次继续以此办法迭代将会得到8*8的矩阵。
[[22 23 26 27 38 39 42 43]
[21 24 25 28 37 40 41 44]
[20 19 30 29 36 35 46 45]
[17 18 31 32 33 34 47 48]
[16 13 12 11 54 53 52 49]
[15 14 9 10 55 56 51 50]
[ 2 3 8 7 58 57 62 63]
[ 1 4 5 6 59 60 61 64]]

附上code：
hilbert
此程序输入输出：
输入：一个数字n
输出：n个hilbert矩阵，二阶，四阶，八阶…
如需题目输入输出样式可自行调节

V1.0更新：

一，对网络结构调整：

1，通过大量实验测试，最终在RESnet50与VGG16中使用VGG16。

2，通过观察爬取的数据集特征，将训练数据集分为5类，分别为”人像“，“食物”，“文字”，“动物”，“风景”。

3，训练100次epoch

4，batchsize=24

5，imagesize = 120

最终实际运行准确度更加趋近稳定，对于动物误识别为人的概率大大减小。

二，增加更多的功能：

1，将屏蔽转发用户写入为block_list文件，从文件中读取屏蔽用户。

2，当用户发送 “@深绘里 -quit”时，可以将自己列入屏蔽列表中，当发送”@深绘里 -join“，可以重新参与被检索。

3，当用户quit or join，通过私信告知用户。

4，为了提高检测精准度，预测图像的时候，对于 长 or 高（比例大于1：1.3） 的图像裁剪为上，中，下，以及整张图resize为正方形的四张图片进行预测，如果有一张检测为人像，并且另外三张没有同时检测为其他同一类型的图片，则正确分类为人像。

5，自动生成日志log文件，存放于log/log_.txt中。

6，修补bug（修改为运行时强制使用CPU运行，不占用GPU显存）。

7，修正被黑名单私信发送失败异常。

程序逻辑设计概要

本文实验采用Python+Keras作为主要语言，使用饭否API接口实现对微博用户上传的图片实时监控，通过多层卷积神经网络对采集图像进行识别，图像符合人群画像标准，则转发。通过对神经网络训练，识别准确率可达到82.5%。点击这里查看微博链接。

卷积神经网络设计

本文采用对Lenet经典神经网络改进网络，网络结构如下：

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

# first set of CONV -> RELU -> POOL layers
model.add(Conv2D(20, (5, 5), padding="same", input_shape=inputShape))
model.add(Activation("relu"))
model.add(MaxPooling2D(pool_size=(2, 2), strides=(2, 2)))
# second set of conv relu pool layers
model.add(Conv2D(50, (5, 5), padding="same"))
model.add(Activation("relu"))
model.add(MaxPooling2D(pool_size=(2, 2), strides=(2, 2)))
# triple set of conv relu pool layers
model.add(Conv2D(20, (5, 5), padding="same"))
model.add(Activation("relu"))
model.add(MaxPooling2D(pool_size=(2, 2), strides=(2, 2)))
# first (only) set of FC relu layers
model.add(Flatten())
model.add(Dense(500))
model.add(Activation("relu"))
# softmax classifier
model.add(Dense(classes))
model.add(Activation("softmax"))

数据集

对数据集采取二分类划分，类别为人像和非人像。数据集收集自饭否网。共计2168张图片，为了提高人像识别度，其中人像大于1.3：1尺寸的图像通过裁剪为三个等比例正方形方法扩展为共计489张。

自动转发系统设计

转发系统采用python语言设计，通过饭否API （https://github.com/FanfouAPI/FanFouAPIDoc/wiki）获取系统微博信息。提取信息中的图像数据，使用训练好的model模型进行预测图像分类，若属于人像分类则通过API自动转发。

自动转发系统日志：

机器人识别效果

通过35次epoch 迭代，训练准确度达到89%左右，验证准确度达到83%左右。由于采取验证图像数据集过于小，所以可以看出图中验证准确度波动较大，且loss较高。

http://fanfou.com/uarepretty/

总结与展望

虽然对于人像可以准确的识别，但是对于一些类人像特征的物体，如猫等。也会被误识别为人像并转发。

其主要原因是网络结构过于浅，无法学习到更细节的特征，仅学习到了如眼睛，脸轮廓等。对于皮肤光滑程度没有很好的识别。如果采取更深层次的网络如ResNet50将会得到更好的效果。

到672医院后，挂号，就诊，拍摄CT查看无骨折。建议回去冰敷修养并建议使用支具支撑（医院收费700，当时并没有购买），腿抬高修养半月。开了几瓶药酒和恢复药物便回校了。

回去之后并没有严格的冰敷，因为感觉找冰还是有点难度的，其实事后想一想还是可以找到的，各种奶茶店或者买个雪糕也可以的。但是当时仅用冷水敷了几天，这大概也延长了恢复时间。另外支具在五天后意识到还是需要一个的，因为睡觉实在是不舒服，网购了支具固定后便方便了很多。另外推荐扶他林，对于轻度崴脚真的好用，止痛效果很好。

总结下来前期的恢复流程最好是：尽快冰敷1-2天+支具固定卧床抬高2周+双拐+后期持续热敷。

但是自身当时没有意识，各个流程都推迟了好多天。这可能也导致恢复缓慢的原因。一直持续到8月才可以正常走路（可缓慢行走），11月才基本恢复正常（但目前仍未尝试跑步等剧烈运动，且冷天需要佩戴脚护踝不能受冻否则会有隐痛，这可能是留下的后遗症吧，需要更长的时间恢复以及平时注意保护）。

希望有崴到脚的朋友引以为戒。另外无痛感后需要进行适当的运动恢复肌肉的功能。

前前言：

事情稍许久远，有些细节也许记忆不清。记录下来供对根管治疗，种植牙，牙齿外伤，智齿拔除等有疑问的患者参考，有任何疑问可留言交流。
本文部分图片可能引起不适，希望有必要的读者【谨慎考虑】后再阅读。

武大口腔就医指导表格

前言：

意外总是突然的。2017年9月8日，本该是研究生开学初期最愉快的一段时期。然而一场意外悄然而来，晚10点后，于校内骑车摔伤。瞬间像梦境一般，血流不止，感受到多颗牙齿的严重折断损伤（想象被摔得满地找牙的画面感）。同时意识到事情的严重性，于第一时间寻找校医院。一番折腾，感谢校园保卫部，校医院以及舍友的帮助下。成功转院至广州军区武汉总医院急诊。

广州军区武汉总医院治疗经历

2017/09.08 初次诊治

当晚急诊，医生检查结果牙齿多颗纵折/冠折+下颌骨具有骨折隐患+面部（下巴）外伤。在医生的建议下，先做了伤口的清洗与缝合上药（这里缝合使用的是普通缝合线，会留下伤疤。后面经过出租司机提醒，或许武大口腔可以使用美容线缝合，伤疤更小。不过我的伤口在下巴， 也就有点无所谓的感觉，除了剃胡子不太方便。），然后拍摄CT检查骨折隐患（报告单如下）。报告单显示未看到明显骨折。在医生的建议下于次日再进行三维重建CT，确认隐患。

伤口缝合后愈合图，可以看到缝合部分不生长胡须，且有疤痕

费用清单

报告清单

2017.09.09 三维重建

凌晨回到寝室休息之后，于次日清晨再次来到广州军区武汉总医院（小插曲：打车的时候遇见一位自称是医生的滴滴司机说：你这个情况应该到武汉口腔医院啊，哪边治疗效果更好，于是在司机的建议下去了口腔医院，拿号（普通号）排队，当时医生并没有考虑到骨折问题，只看了牙齿说要根管治疗（最严重的26）。但是当时考虑医保问题，遂暂缓治疗，回到广州军区总医院复查），要再次感谢辅导员和同学的帮助。这次拍摄了三维CT ，以及换药。三维CT需要等2天后再出片，此时家人也赶过来了，这两天外伤换药等片。三维重建费用较高。
tips: 三维重建这个CT，在武大口腔做的比较好，后面会有对比图。武大口腔的CT可以生成立体图片，甚至可以刻盘保存，而广州军区这里只有多方位的图片，视觉效果有点差。两个医院的实力/设备还是有很大差距的。

费用清单

2017/09/12 住院广州军区武汉总医院

住院期间，在医生的建议下，对治疗下颌骨骨折做了颌间牵引手术（就是在牙床上打钉子，用皮筋将上下牙齿牵引起来，使牙齿，颌骨无法活动）保持一个月后拆除牵引线以及钉子。一开始医生使用了八个牵引钉子，四个牵引线。但是有一个位置骨质疏松，无法固定牵引钉。故最终使用三个皮筋牵引（这里其实个人感觉两个牵引线，四个钉子就足够了，多打了四个孔，痛苦万分）。皮筋的牵引力都很大，一开始受不了痛苦（牙齿外伤有冠折纵折），遂开了洛索洛芬钠 释缓片。由于颌间牵引，所以吃饭全部为流食（后面痛苦的经历就是喝了一个月的豆浆/豆沫！！！连米粥都喝不成）。在医院输液静养一周后办理出院手续，此时下巴外伤也已经拆线（不可思议的是我在住院期间还去考了PET3，佩服自己的willpower）。
tips:做颌间牵引是有后遗症的，就是骨头不会完全对齐，张口左侧骨头会有异响（不知道以后会不会完全恢复如初，恢复到正常使用应该没问题），对于后期的咬合恢复很慢（我不太确定如果手术使用钢板固定会不会好一些，这样可能会留下伤疤）。而且牙齿中缝目前无法对齐。不知和颌骨损伤是否有关系。稍微偏差2mm。不过影响不太大。

正常咬合下侧牙齿有向右轻微偏移

洛索洛芬缓释片

可以看出在牙床上打了四个钉子（看起来像是打在了牙齿上），右侧箭头处有明显骨折线

可以看到，牵引钉子已经拆除，颌骨骨折线也有所愈合。

出院小结

其后多次拍摄影像图，直至骨折恢复后于2018年后开始于武汉大学口腔医院治疗牙齿损伤。

武汉大学口腔医院治疗牙齿

2017/11/17 这是骨折逐渐恢复后第一次来武汉大学口腔医院寻求牙齿损伤的治疗方法。并拍摄3维CT影像。可以看出多颗牙齿折断。当时由于张口仍有一定程度的受限，所以暂缓治疗。

影像图

可以切换视角的3D影像图

2018/01/25 确认治疗方案

多次拜访武汉大学口腔医院后，最终确认治疗方案。
1，洗牙；2，拔除26；3，16/45根管治疗。其他暂缓。

整体建议

2018/03/06 拔牙

犹豫了许久之后，决定先拔除根折无法恢复的26牙齿，本来觉得是很难的事情，因为上牙床骨头稀少，怕拔除时候残片进入上颌窦。所以等主治医师亲自拔牙。打上麻醉之后并没有太多痛感，过程也出乎意料的顺利（10分钟左右）。经过不断晃动就拔掉了根折牙齿26。费用大约800
tips:其实有一种传统的方法，自体牙移植，可以将智齿拔除移动到缺失牙齿的位置，有一定的存活概率，看了不少的论文文献。有的说需要外部根管治疗再移植，有的说可以直接移植成活。最后问了口腔医院，说现在都不做这个了。其实有点遗憾，应该多找一找别的医院。可能有的医院是可以做这个手术的，据说是因为成本低，工艺复杂，所以医生都不想做。
ref：https://www.zhihu.com/question/39629006 https://www.zhihu.com/question/34012960
看到又有新的成功案例，不禁更加后悔当时没有多找一下了。

一些参考文献

恐怖的拔牙工具与根折残片

2018/03/20 根管治疗

这是最近的事情了，做了两个牙齿的根管治疗，都很顺利。16找的主任医生，采用显微镜根管治疗。花费比较高，但是技术很好。根管两次成功，中间相隔20天（由于医生比较忙），第一次开髓，第二次填充。第二次一般不用打麻药，会有点疼。疼到不想再来第二次的那种！费用大约3000左右
其后五月份做了45的根管治疗，这次没有找主任医生，而是副主任。也是两次，间隔一周，很顺利。没有用到显微镜。全部费用大约1000左右

2018/06/07 瘘管

5.20下巴出现瘘管，怀疑是牙源性瘘管。
在线问诊后，又询问校医院，说可能是缝针的排异反应。观察数日后于6.7日有所好转。

咨询在线医生

2018.06.11 武大口腔瘘管咨询

口腔医院检查瘘管，普通号(今天大屏幕叫号器坏了，真是郁闷)，拍摄曲面断层推测不是牙源性瘘管。应该是缝针反应，手术取出需要800左右。决定先观察一段时间，不行就去学校开个转诊再去。

44根折痕迹反而不明显了。

曲面断层

另外咨询了修复科，牙套价格为1000-4000不等，分别为金属，贵金属，烤瓷牙冠，全瓷牙冠。纠结做哪一种中。

2018.07.01 瘘管好转

瘘管好转，留下一点黑斑，无脓包现象。

2018.07.09 下颌骨弹响

下颌骨咀嚼疼痛，但是张口，平时不动并不痛。去武大口腔咨询，回复建议不要熬夜，不要吃硬物观察两周情况依旧就拍片检查。
7.14 依旧疼痛。早餐吃的三明治，无法完全咀嚼。
大约7.20 有所好转。

2018.07.16 咨询种植牙

咨询种植牙，花了366又拍了cbct 。和上次的差不多，说可以种植。种植的时候需要增加骨粉，大概是14000+2000左右。时间10个月左右。另外cbct中看到44根折线没有以前明显了，暂时还是不管44了。种植科的专家号很少，都要预约，副主任在10月了，主任在明年3月了真的是要尽早预约的 。
最终预约了白轶医生 11.5的副主任号

名片

2018.08.26 拔智齿

一直感觉智齿有点不舒服，但是也没有很疼，就是像没有刷干净牙齿，卡了东西一样，今天终于决定去拔掉一颗智齿。
这次拔掉的是38，挂的副主任吴杨的号。拔牙的是他的一个实习生，可能是我的情况不是很复杂的原因吧。用一个一字螺丝刀一样的东西，在牙床边缘翘了几下就掉了。拔掉的牙齿忘了拍照，牙齿的型态和下面的图片有点相似（几个牙根连在一起了，不像27，三个压根很明显），费用一共是400左右。

智齿（网图）

2018.09.07 拔另一颗智齿

挂了个普通号，费用又是400左右，本来可以在学校拔的的，但是当天学校新生体检不接受挂号，加上实习工作日少有时间，还是去了武大口腔 这个牙齿的形态还是比较正常的。拔完之后吃了几天药，现在一周过去稍微好点了。不过有次吃东西感觉点进去米饭一样，然后牙签挖了下给捅进去了？感觉现在都没出来，以后拔牙吃饭掉进去东西千万不要乱搞，漱口就可以。

智齿图

2018.10.24 程序员之日

在今天这个程序员之日，我做了一个重大的决定，就是拔掉44牙齿，经过长久的忍耐与对抗，终于下定决心拔掉这个根折的牙齿。拔牙之前签订了一个《可吸收生物膜临床试验》协议，简单来说就是参与临床试验，可以省去将来种植牙植入骨粉的钱，考虑到不会有太严重的副作用就参与了。

临床试验

然后体检了血液等，今天来做手术拔牙。由于长期滞留的根折牙齿，拔牙的时候并不是很顺利，牙冠部分首先被拔出来，然后用各种工具去挖里面的牙根，牙根和骨头有了可能有了骨粘连，大概花了20分钟反复尝试才最终拔出来，特别担心之前骨折的地方会不会受到影响。

感觉上好像不是一个完整的牙根。。难道是有残根留在了里面？

之后就是植入骨粉，大概五分钟的时间，像是用刀子在刮牙槽骨一样的感觉.. 然后覆生物膜，缝针，去拍了个CBCT，结束。真是个痛苦的经历啊。最后这次的费用是200拔牙 + 500骨粉手术费，CBCT属于临床试验费用，骨粉的材料费用也免除了。后续还会有600的回访补贴返还。

2018.11.19 种植牙

到目前为止，终于基本上结束了牙齿的治疗过程，要进入到修复阶段了。
再11.5日的时候就咨询过白轶医生，定下来的方案是13000的种植体+上颌窦提升手术+骨粉=预计17000左右。
种植体有多种不同类型，但是基本上没必要特意选择，价格的差距主要是表面处理不同，一般良好的牙槽骨以及恢复速度是对表面处理没有太大要求的，所以选择了13000的种植体，还有1.5W 以及1.8W的。
种植牙所在的手术间是内部的独立手术室，进去之前需要换鞋，保证了环境的干净。我记得查的白轶医生是男医生，然后给我手术的是女医生，难道是我记错了吗。其实整个过程还是比较顺利的， 医生说上颌窦的膜比较薄，容易穿透，最后还是成功植入了。
首先打麻药，消毒，用布把眼睛身体都盖住，只留出嘴巴。用小钻头钻牙槽骨，然后用锤子之类的东西再孔内敲击，进行上颌窦内提升（我之前查的以为是外提升，看了视频真的是吓了一跳，内提升还好，就是不断敲击，有点恐怖，但是伤口并不大，然后放入种植体。完了之后打了三天的消炎针 ，吃了戴芬止痛药。止痛药必须要吃，不然真的会痛到睡不着的。
此次一期费用约8000左右，二期是半年后进行牙冠修复，希望可以一切顺利。

2018.12.04 种植牙-拆线复查

最近懒床严重，九点才起床。到医院已经是接近10点，本来不确定还能不能挂到号，结果人还是很少的， 直接来复诊挂号，前面0人排队，很快就到了。缴费100，拍片，不用取，直接上来护士拆线即可。
CT片上这张图看起来种植体胖胖的，不过可能后排牙齿都是这样的吧。
接下来是6个月后来做二期手术，大概5月中旬，需要提前打电话与白医生预约。顺便夸一下护士小姐姐真的好温柔啊（捂脸

2019.02.01 颞下颌关节症状复发。

奇怪的是，撞伤骨折的是左侧颌关节，过年的时候疼痛的反而是右边的颌关节。主要表现为张口疼痛，咬合疼痛。热敷之后会有所好转，准备到学校之后再好好看一下。另外，牙齿的排列先比以前上下中缝之间的差距也更大了一些，不知道是拔牙的原因还是颌关节的原因。

2019.02.22 颌关节复查

去医院检查颌关节，医生说是颞下颌关节不可复盘移位。

拍了造影和CBCT，显示颌骨部分有磨损。

左侧颌骨

右侧颌骨
可以看到右侧颌骨明显更加毛糙一些。医生说是关节处骨头磨损严重，表面的一些物质磨损掉了所以会感到疼痛，建议打透明质酸针看看疗效。或者自己修养不要乱动。
让我很困惑的是不知道什么原因就成这样了，真的很烦躁了。

2019.03.06 牙冠修复/下颌骨情况

其实前几天就想去做16牙齿的牙冠修复了，但是每次都起床起晚了，昨天是7点中出宿舍，到医院大概七点半了，排队伍的人已经挤满了大厅。觉得还是放弃了，于是今天5.30就起床，6.50到医院排队。这就让我想起了旅行者困境问题，明明7.30才开始挂号，每个人都想我如果提前1分钟就可以排在90%的人前面，当所有人都这么想，于是，硬生生地大家一起多排队半个小时（是不是以后挂号都要带马扎。
来到医院之后首先挂了4楼修复科室的专家号，修复科医生建议做牙冠修复（金属烤瓷1k+,贵金属烤瓷3k+，全瓷4k+）。因为之前有了解过嵌体，感觉上要比烤瓷牙的磨损更少，硬度也相差不大，于是问了医生是否可以做嵌体，之后医生说嵌体一般是3楼牙体牙髓科室做的，让我去哪里问一下。我又去了三楼挂了黄医生的号……经过漫长的等待（2h左右），黄医生接诊了我，在简单的查看后，建议由于缺损较大， 嵌体无法修复，可以做cadcam全冠修复（使用cadcam技术相比普通全瓷牙要廉价1000左右。cadcam全瓷冠修复是3.7k，全瓷牙是4.5k）。医生把我的牙齿磨掉了一圈，然后下午去精密科室（好像是这个）拍照做全瓷牙冠。待到下午2点，直接去了精密科室，医生用一个小模型采集器（摄像头）对16牙齿周围拍照扫描建模，如图所示。

很快就做好了大概一个小时，3.30之后医生就来叫我，把牙冠用胶水黏上之后再打磨一下就好了。
说一下结论把，这个cadcam全冠的优点：1，普通全瓷牙冠一般都是要一周才能做好带上。2，价格上比全瓷牙冠少了1k。
使用感受良好，至于能用多久就不清楚了。

一张注意事项图

ref:

许琼莉, et al. CEREC AC 及 MC XL 椅旁 CAD/CAM 全瓷修复的护理配合. Diss. 2013.

另外，关于下颌骨，目前已经有所好转（不过看牙齿的时候张口那么久还是有一些难受，都麻木了），还没有打透明质酸针。觉得真的心态还是很重要，保持乐观就解决了一大半的病因。

2019.05.20 种植牙手术二期。

这次手术很简单，不过依旧是去内部的消毒手术室，打了点麻药，把内部的种植体露出来，然后将基台放入种植体上，预计再过十天之后去取牙模，做牙冠。

2019.05.23 45牙齿的牙冠

今天早晨醒来发现45牙齿竟然裂了一条缝隙，于是急忙去医院看了一下，找了黄冰冰医生，下午拍摄了CAD影像以及将牙齿磨成圆形。第二天去将做好的牙冠装好。整个过程都比较顺利，牙冠装上之后和别的牙齿看起来没有异样，就是相对别的牙齿感觉要更为光滑一点。

2019.05.30 种植牙取模型

由于种植牙无法采用倚旁cad的方式进行制作牙冠,所以采用了传统的通过取模型制作牙冠的方法.

取模型的时候使用橡皮泥一样的物质在牙齿上压制形成模型,后续将模型送至工厂进行制备牙冠.原本以为制备牙冠只需要一周就可以解决,最后被告知需要40day才可以制作完成牙冠.无奈只能等待到7月中旬(然而七月中旬我将离开武汉去往广州工作),大约花费1k.

2019.09.12 种植牙牙冠修复

由于新就职期间请假不太方便,且当时牙冠安装需要周二-周四才可以安装.所以一直等到了九月份才有时间来安装牙冠.

牙冠以及如图所示,整个过程比较顺利,没有太多的不适感,牙冠不是通过胶水黏贴的,而是嵌入到基台内部的.牙冠的体积相对于对面的16来说小了很多,这很大程度是由于长期没有修复牙齿而导致牙齿间隙变小,且26与27牙齿之间不是很平整,感觉会有异样,但是饮食无碍,塞牙问题不大.

种植牙消费总计

共计消费 11288.7 ,比预计的花费要少一些.

首次挂号费 16.5
种植牙手术 8407.4
两次复诊CT 126.5 126.5
牙冠制作 1146.5
牙冠安装 1465.3
详细账单下载:
武汉大学口腔医院种植牙账单.zip

利用CNN和DNN完成Mnist识别任务，CNN结构如下所示，DNN结构自定，将效果作为baseline。

使用DNN，结构

1
2
3
4
5
6

Dense(32, input_dim=784),  # 全连接层。32个神经元，输入维度为784（28*28）
Activation('relu'),  # 激活层
Dense(10),  # 全连接层，10个神经元
Activation('softmax')  # 激活层
nb_epoch=1, batch_size=32
model.fit(X_train, y_train, nb_epoch=1, batch_size=32)

两次效果：

test loss: 0.21429610718488692
test accuracy: 0.9395
test loss: 0.21414068414568901
test accuracy: 0.9399

使用CNN结构

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

conv_1 = Conv2D(32, kernel_size=(3, 3), activation='relu', input_shape=input_shape)
conv_2 = Conv2D(64, (3, 3), activation='relu')
model = Sequential()
model.add(conv_1)
model.add(conv_2)
model.add(MaxPooling2D(pool_size=(2, 2)))
model.add(Dropout(0.25))
model.add(Flatten())
model.add(Dense(128, activation='relu'))
model.add(Dropout(0.5))
model.add(Dense(num_classes, activation='softmax'))
batch_size = 128
num_classes = 10
epochs = 1
model.fit(x_train, y_train,
          batch_size=batch_size,
          epochs=epochs,
          verbose=1, validation_data=(x_test, y_test))

两次效果：

Test loss: 0.06023046794650145
Test accuracy: 0.9816
Test loss: 0.06867549542314373
Test accuracy: 0.9775

结论：在同样的epoch下，cnn效果更好，时间更长。Dnn只要10s CNN需要5min

显示CNN的第一层（卷积层），第二层（激励层）的输出图片(输出其中9张)

Mnist中的每个图片做subsampling（研究两种方式，随机采样和抛弃一半），分别利用CNN和DNN在新样本集合作训练，考察subsampling对实验效果的影响（训练误差，测试误差，训练速度），考虑如何减小subsampling的影响。

四倍降采样之后的结果：

CNN：
运行时间：从5min变为为50s。
两次效果：
Test loss: 0.08262749407133088
Test accuracy: 0.9757
Test loss: 0.07995445217452943
Test accuracy: 0.9744
结论：测试误差不大。
DNN:
训练时间约为5s
test loss: 0.2969126805961132
test accuracy: 0.9169
结论：误差相对仍较大。

设置抛弃一半之后的效果：

CNN:
运行时间在2min左右。
两次测试效果：
Test loss: 0.19521159455776216
Test accuracy: 0.9417
Test loss: 0.1949758700400591
Test accuracy: 0.9389
结论：测试误差进一步增大，但是仍保持较高的准确率。
DNN：
训练时间约为5s
test loss: 0.39655784153938295
test accuracy: 0.8881
结论：误差相对CNN更大。

取原训练集前10%的样本做训练，测试集不变，考察CNN和DNN效果，考虑如何减小小样本集的影响。

CNN：
两次运行结果：
Test loss: 0.29531892013549804
Test accuracy: 0.9097
Test loss: 0.3230072082400322
Test accuracy: 0.9173
DNN：
两次运行结果：
test loss: 0.4636564645767212
test accuracy: 0.8762
test loss: 0.46389272186756136
test accuracy: 0.8767
通过调整nb_epoch=10，增加训练次数可优化测试结果：
test loss: 0.27507588347643613
test accuracy: 0.9222
继续增大epoch 将对结果影响不大（修改nb_epoch=100）：
test loss: 0.62979790314195
test accuracy: 0.9262

尝试对DNN增加池化层和Dropout层，考察DNN效果变化。

无pooling层可对DNN池化（维度不一致）。
添加dropout(0.55):
test loss: 0.3060034876406193
test accuracy: 0.9186
添加dropout(0.80):
test loss: 0.5026416866779327
test accuracy: 0.8948
添加dropout(0.99):
test loss: 2.2277009323120116
test accuracy: 0.2207
结论：保持一定比例的dropout不会对结果产生太大影响，速度会有所提升。但是接近1时，将无法识别数据。

对kernel_size进行调整（一起调整，或者逐层调整），考察CNN效果变化。思考如何选择kernel_size

修改kernel_size =conv1 (5,5),conv2(3,3):
Test loss: 0.04961018333421089
Test accuracy: 0.9844
结论：影响不大。准确率略有提高。
修改kernel_size=conv1(2,2),conv2(8,8):
Test loss: 0.04970626147154253
Test accuracy: 0.9824
结论：时间消耗为15min，效果无显著提升。可适当提升第一层卷积核，有助于提高识别率。

作业任务2：研究如何“欺骗”DNN和CNN

输出DNN和CNN认为最像“8”的图片

DNN（most likely eight）：
可能性: 0.9992219位置 5003

CNN（most likely eight）:
可能性: 0.99999833位置 7114

在真实“8”图片上加入噪声，让DNN与CNN认为它是“9”

DNN fake9:

预测值的概率：
[[4.0106301e-07 1.8723180e-05 2.6028445e-05 4.2457259e-04 2.4138275e-04 2.7176596e-03 1.5008907e-06 3.7194110e-02 4.5580325e-01 5.0357234e-01]]
最可能的值： 9
CNN fake9:

预测值的概率:
[[0. 0. 0. 0. 0. 0. 0. 0. 0. 1.]]
最可能的值：
结论：若使用DNN的fake9样例，仍可识别为8

预测值的概率:
[[0. 0. 0. 0. 0. 0. 0. 0. 1. 0.]]
最可能的值： 8

code：点击这里