outsize = (insize - fsize + 2*pad) / stride + 1totstride = totstride * stride，这两个公式都是从前往后算RF = ((RF -1)* stride) + fsize，这个要从后往前算1 | #!/usr/bin/env python |
1 | layer output sizes given image = 224x224 |
$$
E(x)=\sum _i\theta_i(x_i)+\sum {ij}\theta{ij}(x_i,x_j)
$$
$$
\theta_i(x_i) = -logP(x_i)
$$
$$
\theta_{ij}(x_i, x_j)=\mu(x_i, x_j)[\omega_1exp(-\frac{\left |p_i-p_j \right |^2} {2\sigma_\alpha^2}-\frac{\left |I_i-I_j \right |^2}{2\sigma_\beta^2})+\omega_2exp(-\frac{\left |p_i-p_j \right |^2} {2\sigma_\gamma^2})]
$$
1 | import numpy as np |
1 | rand('twister', 1337); |
1 | #include <iostream> |
最简单的生成算法，混合同余法，可以看这里
c++11的random库，可以参考这里
coursera北大的c++课上的一道题，本地ok，poj(pku的OJ)上ok，垃圾coursera上compile error。
先贴在这里，我感觉写的还是很优雅的。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
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244#include <iostream>
#include <algorithm>
#include <string>
using namespace std;
class BigInt {
public:
BigInt(){
values = "0";
flag = true;
}
BigInt(const string stringvalue){
values = stringvalue;
flag = true;
}
BigInt(const int intvalue){
if (intvalue >= 0){
values = to_string(intvalue);
flag = true;
}
else{
values = to_string(-intvalue);
flag = false;
}
}
//~BigInt();
friend ostream& operator << (ostream& out, const BigInt& b);
friend istream& operator >> (istream& in, const BigInt& b);
BigInt& operator + (BigInt b);
BigInt& operator - (BigInt b);
BigInt& operator * (BigInt b);
BigInt& operator / (BigInt b);
bool operator >= (BigInt b);
//private:
string values;
bool flag;
};
bool BigInt::operator >= (BigInt b){
int agb = 0;
if (values.length() > b.values.length())
{
agb = 1;
}
else if (values.length() < b.values.length())
{
agb = -1;
}
else
{
agb = values.compare(b.values);
}
return agb>=0;
}
BigInt& BigInt :: operator + (BigInt b) {
if (flag == b.flag){
string res = "";
reverse(values.begin(), values.end());
reverse(b.values.begin(), b.values.end());
int i = 0, carry = 0;
for (; i < values.length() && i < b.values.length(); ++i){
int tmp = values[i] - '0' + b.values[i] - '0' + carry;
carry = tmp / 10;
tmp = tmp % 10;
res = (char)(tmp + '0') + res;
}
if (i < values.length()){
for (; i < values.length(); ++i){
int tmp = values[i] - '0' + carry;
carry = tmp / 10;
tmp = tmp % 10;
res = (char)(tmp + '0') + res;
}
}
else if (i < b.values.length()){
for (; i < b.values.length(); ++i){
int tmp = b.values[i] - '0' + carry;
carry = tmp / 10;
tmp = tmp % 10;
res = (char)(tmp + '0') + res;
}
}
if (carry == 1)
res = '1' + res;
values = res;
}
else{
int agb = 0;
if (values.length() > b.values.length())
{
agb = 1;
}
else if (values.length() < b.values.length())
{
agb = -1;
}
else
{
agb = values.compare(b.values);
}
if (0 == agb)
{
values = "0";
return *this;
}
else if (agb < 0){
flag = !flag;
string tmp = values;
values = b.values;
b.values = tmp;
}
string res = "";
reverse(values.begin(), values.end());
reverse(b.values.begin(), b.values.end());
int i = 0;
for (; i < values.length() && i < b.values.length(); ++i)
res.push_back(values.at(i) - b.values.at(i) + '0');
if (i < values.length())
for (; i < values.length(); ++i)
res.push_back(values.at(i));
int carry = 0;
for (i = 0; i < values.length(); ++i)
{
int newValue = res.at(i) - carry - '0';
if (newValue < 0) carry = 1;
else carry = 0;
res.at(i) = newValue + carry * 10 + '0';
}
while (res[res.length() - 1] == '0')
res.pop_back();
reverse(res.begin(), res.end());
values = res;
}
return *this;
}
BigInt &BigInt::operator - (BigInt b)
{
BigInt tmp(b);
tmp.flag = !tmp.flag;
return *this+tmp;
}
BigInt &BigInt::operator * (BigInt b)
{
BigInt res;
if (values == "0" || b.values == "0"){
values = "0";
return *this;
}
if (flag == b.flag)
flag = true;
else
flag = false;
BigInt thisbk(*this);
for (int i = 0; i < b.values.length(); ++i){
for (int j = 0; j < b.values[i] - '0'; ++j){
res = res + thisbk;
}
res.values.push_back('0');
}
res.values.pop_back();
values = res.values;
return *this;
}
BigInt &BigInt::operator / (BigInt b)
{
if (b.values == "0")
throw "Division by zero condition!";
if (flag == b.flag)
flag = true;
else
flag = false;
BigInt one(1);
while (*this >= b){
b.values.push_back('0');
one.values.push_back('0');
}
b.values.pop_back();
one.values.pop_back();
BigInt thisbk(*this), res(0);
while (one.values.compare("0") > 0){
while (*this >= b){
*this - b;
res + one;
}
b.values.pop_back();
one.values.pop_back();
}
values = res.values;
return *this;
}
ostream& operator << (ostream& ou, const BigInt& b)
{
if (!b.flag)
ou << '-';
ou << b.values;
return ou;
}
istream& operator >> (istream& in, BigInt& b)
{
string str;
in >> str;
b.values = str;
return in;
}
int main()
{
BigInt b1, b2;
string str;
cin >> b1 >> str >> b2;
if (str == "+")
{
cout << b1 + b2 << endl;
}
else if (str == "-")
{
cout << b1 - b2 << endl;
}
else if (str == "*")
{
cout << b1 * b2 << endl;
}
else
{
cout << b1 / b2 << endl;
}
return 0;
}
然后根据这个概率图，使用类似动态规划的思路，可以计算出ctc loss和导数
不想写了，看下面这篇吧
cin 带空格的字符串时，需要这样cin.getline(s, 80)，s是char数组
或者也可以这样getline(cin, str)，原型为istream& getline (istream& is, string& str); ，C++对每种流都定义了一个getline函数
在gcc编译器中，对标准库进行了扩展，加入了一个getline函数。会自动malloc, realloc，所以用的话，需要自己手动free，好像没啥人用，参考这里
cout 控制输出精度 cout << fixed << setprecision(2) << f，#include <iomanip>
cout 控制输出格式cout << setfill('0') << setw(4) << a[i][j]
cin cout 重定向
1 | freopen("foo.txt","w",stdout); |
lambda表达式
使用lambda对vector进行排序
1 |
|
erase删除vector元素
1 | for(it=iVec.begin();it!=iVec.end();){ |
Sample a(0), Sample a = 0, 都是调用构造函数
Sample a(9); a = 8 调用两次构造函数，
Sample b = a , Sample b(a) 拷贝构造函数
类型转换构造函数，编译系统会生成一个临时变量
C++编译器遵循以下优先顺序:
先找参数完全匹配的普通函数(非由模板实例化而得的函数)，再找参数完全匹配的模板函数，再找实参经过自动类型转换后能够匹配的普通函数，上面的都找不到, 则报错。
优雅的内存对齐方法
1 | unsigned int calc_align(unsigned int n, unsigned align) |
__declspec(dllexport)是导出声明，说明这个函数要从DLL中导出给别人用。
__declspec(dllimport)是说这个函数是从别处导入的，不适用也能正常编译代码。
ANSI C是美国国家标准局，为C语言制定的一套国际标准语法，避免各个厂家的C语言不一致
include的文件可以不写到gcc里面
1 | #include "max.c" |
1 | gcc -c max.c -o max.o |
var email = $('[name=email]');1 | var div = $('#abc'); // jQuery对象 |
1 | $('ul.lang li'); // 选出JavaScript、Python和Lua 3个节点 |
element element是后代就可以，element>element必须是父子1 | $.ajax({ |
1 | $.ajax({ |
