发表于 | 更新于: | 分类于 | | 阅读次数:
字数统计: 1.8k 字 | 阅读时长 ≈ 9 分钟

cycleGAN 模型属于 GAN 模型的一个变形，在很多情况下，我们无法获得或者很难获得成对的训练数据，cycleGAN 要解决的问题是： seek an algorithm that can learn to translate between domains without paired input-output examples，如下图：

其中，cycleGAN 的网络结构如下图所示：

阅读全文 »

发表于 | 更新于: | 分类于 | | 阅读次数:
字数统计: 4k 字 | 阅读时长 ≈ 20 分钟

该篇博文使用 cGAN 实现了 image to image translation，由于 cGAN 可以通过添加条件来指导图像的生成，因此用此图像翻译技术，可以很好的实现诸如图片着色等任务，具体模型参考 此篇论文 。

pix2pix 模型使用输入图像(x)作为条件（这里没有噪声输入 z, 可以把 G 的输入 x 看做是噪声 z），学习从输入图像到输出图像的映射，从而得到指定的输出图像。具体过程如下图：

传统图像转换过程中都是针对具体问题采用特定算法去解决，而这些过程的本质都是根据像素点（输入信息）对像素点做出预测(predict from pixels to pixels)，pix2pix的目标就是建立一个通用的架构去解决图像翻译问题，使得我们不必要为每个特定任务都重新设计一个损失函数。但是该模型也有一定的缺点，pix2pix在训练时需要成对的图像（x和y），模型学到的是 x 到 y 之间的一对一映射。也就说，pix2pix就是对ground truth的重建：输入轮廓—>经过Unet编码解码成对应的向量—>解码成真实图。这种一对一映射的应用范围十分有限，当我们输入的数据与训练集中的数据差距较大时，生成的结果很可能就没有意义，这就要求我们的训练数据集要尽量涵盖各种类型。以轮廓图到服装为例，我们在自己的数据集上训练好模型，当输入与训练集中类似的轮廓图时得到以下结果：

阅读全文 »

发表于 | 更新于: | 分类于 | | 阅读次数:
字数统计: 2.2k 字 | 阅读时长 ≈ 11 分钟

接上一篇DCGAN手写数字生成，虽然它能够生成效果不错的手写数字图片，但它有一个缺点就是不能生成指定数值的数字，好在有一种 GAN 模型叫 cGAN，即 Conditional Generative Adversarial Nets， 出自 此篇论文，它能够生成指定数值的数字图片。

模型结构如下图：

其损失函数定义：

阅读全文 »

发表于 | 更新于: | 分类于 | | 阅读次数:
字数统计: 2.2k 字 | 阅读时长 ≈ 10 分钟

最近忙里偷闲，补一发之前落下的关于一些GAN的tensorflow2.0实现代码。

首先，GAN ，即生成对抗网络Generative Adversarial Network，由一个生成器Generator和一个判别器Discriminator组成，两者属于 零和博弈 的双方，不是你死就是我亡的状态。

其损失函数一般定义如下：

判别器 D 对来自真实数据集的样本 $x\sim p_{data}$ 要输出大概率，越接近 1 越好；对来自生成器生成的样本$z\sim p_z$ 要输出小概率，越接近 0 越好。当然，这是一个零和博弈，对于生成器G来说，其目标与D截然相反，他想使自己生成的样本不能被D识别出来。这么不断的你来我往，双方各自不断调优，最后达成一个平衡状态。

当然，这其中的损失函数也不只这一种，比如说，生成器的损失函数可以定义为：生成样本分布与真实样本分布的 KL 散度值等。

KL 散度用来衡量两个分布之间的相似性。

阅读全文 »

发表于 | 更新于: | 分类于 | | 阅读次数:
字数统计: 810 字 | 阅读时长 ≈ 2 分钟

一、前言

天朝 qiang 越垒越高，买的境外的服务器用时间长了经常会出现 IP 被 ban 的情况，本教程通过 v2ray+websocket(ws)+TLS 将流量伪装成 TLS 流量，即将自己的境外转发服务器伪装成一个网站，并通过 cloudflare 中转，网络流量流经图如下：

这样的话，防火墙就只知道你和 CDN 之间建立了连接，不知道你的 vps 实际的 IP 地址，这样就可以有效的防止你的 IP 被 ban，并且 CDN 会有很多 IP 地址，防火墙也不会随意去 ban 他们的 IP，毕竟也有很多正规的网站在使用，所以基本上可以确保你的 IP 的安全。

阅读全文 »

发表于 | 更新于: | 分类于 | | 阅读次数:
字数统计: 541 字 | 阅读时长 ≈ 2 分钟

1、source 命令

1
source filename

在当前 bash 环境下读取并执行 filename 中的命令。

2、环境变量分为 永久环境变量 和 临时环境变量

永久环境变量：修改配置文件，/etc/profile, /etc/.bashrc, ~/.profile, ~/.bashrc 等，

临时环境变量：使用 export 命令声明即可，变量在关闭shell时失效。

阅读全文 »

发表于 | 更新于: | 分类于 | | 阅读次数:
字数统计: 2.9k 字 | 阅读时长 ≈ 9 分钟

1、Go 语言更高效的利用计算机CPU上的所有核心，更高效的复用代码。

2、Go 语言自带垃圾回收器，不需要用户自己管理内存。

3、使用 goroutine 并发，使用 通道 避免其他语言中的共享内存访问的问题，减少了锁 或者 同步机制。

4、Go 语言的每个代码文件都属于一个包，一个包定义一组编译过的代码，包的名字类似于命名空间。处在同一个文件夹里的代码文件，必须使用同一个包名，按照惯例，包和文件夹同名。

5、Go 编译器为了让程序的可读性更强，不允许声名导入某个包却不使用。解决方法： 在导入的路径前加一个 下划线 ，这样它会调用对应包内的所有代码文件里定义的 init 函数，进行初始化操作。

阅读全文 »

发表于 | 更新于: | 分类于 ， | | 阅读次数:
字数统计: 838 字 | 阅读时长 ≈ 4 分钟

81、搜索旋转排序数组 II

二分搜索，注意第 34 行的 L = L + 1 的条件判断，在最坏情况下，会使得该二分搜索退化为 O(N) 的时间复杂度。

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
class Solution {
public:
    bool search(vector<int>& nums, int target) {
        if(nums.size()==0)
            return false;
        int L = 0, R = nums.size()-1, mid;
        while(L <= R){
            cout << "L: " << L << ",  R: " << R << endl;
            mid = (L + R) >> 1;
            if(nums[mid]>nums[L]){
                if(target==nums[mid])
                    return true;
                else if(target>nums[mid])
                    L = mid + 1;
                else if(target>=nums[L])
                    R = mid - 1;
                else
                    L = mid + 1;
            }
            else if(nums[mid]<nums[L]){
                if(target==nums[mid])
                    return true;
                else if(target<nums[mid])
                    R = mid - 1;
                else if(target<=nums[R])
                    L = mid + 1;
                else
                    R = mid - 1;
            }
            else{ // nums[mid] == nums[L]
                if(target==nums[mid])
                    return true;
                else
                    L = L + 1;
            }
        }
        return false;
    }
};

82、删除排序链表中的重复元素 II

模拟题

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
class Solution {
public:
    ListNode* deleteDuplicates(ListNode* head) {
        if(!head)
            return NULL;
        ListNode *new_head = new ListNode(0);
        ListNode *new_p = new_head, *ptr=head;
        long long int num = 1e10;
        while(ptr!=NULL){
            if(ptr->next!=NULL && ptr->val==ptr->next->val){
                num = ptr->val;
                ptr = ptr->next;
            }
            else if((long long int)(ptr->val)==num){
                ptr = ptr->next;
            }
            else{
                new_p->next = ptr;
                ptr = ptr->next;
                new_p = new_p->next;
                new_p->next = NULL;
            }
        }
        return new_head->next;
    }
};

83、删除排序链表中的重复元素

模拟题，线上代码铁定不能这么写，内存泄露有木有！

1
2
3
4
5
6
7
8
9
10
11
12
13
14
class Solution {
public:
    ListNode* deleteDuplicates(ListNode* head) {
        ListNode *new_head = head, *p = head;
        while(p!=NULL){
            if(p->next!=NULL && p->val==p->next->val){
                p->next = p->next->next;
                continue;
            }
            p = p->next;
        }
        return new_head;
    }
};

84、柱状图中最大的矩形

一个很自然的想法是，以当前柱子为高，向两边遍历，时间复杂度为 $O(n^2)$。降低复杂度的关键是，如何快速找到以当前柱子为高的左右边界left_index 和 right_index，维护一个单调的递增栈 >=，即可快速找到 left_index 和 right_index。具体如代码第 14 行所示，整体时间复杂度为 $O(n)$ 。

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
class Solution {
public:
    int largestRectangleArea(vector<int>& heights) {
        if(heights.size()==0)
            return 0;
        stack<int> index;
        index.push(-1);
        int max_area = 0, N = heights.size(), h;
        for(int i=0; i<N; i++){
            if(index.size()>1 && heights[i]<heights[index.top()]){
                while(index.size()>1 && heights[i]<heights[index.top()]){
                    h = heights[index.top()];
                    index.pop();
                    max_area = max(max_area, h*(i-index.top()-1));
                }
            }
            index.push(i);
        }
        while(index.size()>1){
            h = heights[index.top()];
            index.pop();
            max_area = max(max_area, h*(N-index.top()-1));
        }
        return max_area;
    }
};

85、

86、分隔链表

使用两个指针即可。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
class Solution {
public:
    ListNode* partition(ListNode* head, int x) {
        ListNode *big_head = new ListNode(0), *small_head = new ListNode(0);
        ListNode *big_p = big_head, *small_p = small_head, *p = head;
        while(p){
            if(p->val < x){
                small_p->next = p;
                p = p->next;
                small_p = small_p->next;
                small_p->next = NULL;
            }
            else{
                big_p->next = p;
                p = p->next;
                big_p = big_p->next;
                big_p->next = NULL;
            }
        }
        small_p->next = big_head->next;
        return small_head->next;
    }
};

88、合并两个有序数组

一个小的 trick 是从后往前遍历，时间复杂度 $O(n+m)$, 空间复杂度 $O(1)$ 。

1
2
3
4
5
6
7
8
9
10
class Solution {
public:
    void merge(vector<int>& nums1, int m, vector<int>& nums2, int n) {
        int p1 = m-1, p2 = n-1, index = m+n-1;
        while(p1>=0 && p2>=0)
            nums1[index--] = nums1[p1]>=nums2[p2]? nums1[p1--] : nums2[p2--];
        while(p1+p2>=-1)
            nums1[index--] = p1>=0? nums1[p1--] : nums2[p2--];
    }
};

发表于 | 更新于: | 分类于 | | 阅读次数:
字数统计: 1.2k 字 | 阅读时长 ≈ 4 分钟

闲来没事苟着，顺手读读之前买的已经落灰的书《Docker实战》。

1、daemon（守护进程），运行中的 docker 由守护进程（服务端）和客户端组成(通过unix域间套接字通信），比如说，执行：docker ps -a 命令，是客户端将命令传送给守护进程，由守护进程发送对应的响应给前端，前端解析并显示。可以通过如下操作查看docker守护进程和客户端的通信过程:

1
2
3
4
sudo socat -v UNIX-LISTEN:/tmp/dockerapi.sock UNIX-CONNECT:/var/run/docker.sock
## 其中 socat 是 netcat(nc) 命令的升级版，-v 参数有助于人阅读 address1 address2 可以是 tcp、udp或 socket等
docker -H unix:///tmp/dockerapi.sock ps -a
##  -H 参数指定 docker daemon socket(s) to connect to.

阅读全文 »

发表于 | 更新于: | 分类于 ， | | 阅读次数:
字数统计: 1.4k 字 | 阅读时长 ≈ 8 分钟

71、简化路径

模拟题

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
class Solution {
public:
    string simplifyPath(string path) {
        for(int i=1; i<path.length(); i++){
            if(path[i-1]=='/' && path[i]=='/')
                path.erase(i--,1);
        }
        if(path[path.length()-1]=='/')
            path.erase(path.length()-1);
        vector<string> fenduan;
        int pos = 0, index;
        while(pos>=0 && pos<path.length()){
            index = path.find('/', pos+1);
            fenduan.push_back(path.substr(pos, index-pos));
            pos = index;
        }
        string ans = "";
        for(auto i : fenduan){
            if(i=="/.")
                continue;
            else if(i=="/.."){
                index = ans.find_last_of('/');
                if(index>=0 && index<ans.size())
                    ans.erase(index);
            }
            else
                ans += i;
        }
        if(ans.size()==0)
            ans = "/";
        return ans;
    }
};

阅读全文 »
0%