values[:,4] = encoder.fit_transform(values[:,4])
是指 按照 values当中的第五列进行编码吗？ 第五列是PM2.5，而且PM2.5指数相等的话 编码值也相等。
刚刚随便写了一个test.csv验证了一下好像是这样的。
那个
values.astype('float32')
遇到含有字符的话是不可以转化的！！那个原始csv里面有一列写的NW就没办法识别，但是NA可以。
遇到的第一个函数
# Normalized
scaler = MinMaxScaler(feature_range = (0, 1))
scaled = scaler.fit_transform(values)
第二个函数
# Sliding window
reframed = series_to_supervised(scaled, 18, 1)
index_col = 18 * 8
def series_to_supervised(data, n_in = 1, n_out = 1, dropnan = True):
#n_vars就是属性个数吧（列数） shape[1]指的是第二维的长度
n_vars = 1 if type(data) is list else data.shape[1]
#转化格式罢了 转成dataframe，这样就会多出（表示行数列数编号0 1 2 3 4那种）部分，但这个编号不算在最后计算数据rows and columns当中的
df = DataFrame(data)
cols, names = list(), list()
#(t-n, ... t-1) 这里n_in传进来18不知道为什么
for i in range(n_in, 0, -1):
#这里shift(i)是把整个df向下移动i行，前面空出来的部分是nan，然后存进cols这个list当中
cols.append(df.shift(i))
#names和cols规模一样的，对应的是名字罢了，比如说第一行就写的是var0(t-18) var1(t-18)……
names += [('var%d(t-%d)' % (j + 1, i)) for j in range(n_vars)]
#(t, t+1, ... t+n) 这部分n_out传进来是1啊，有意义吗？只计算量var(t)。
for i in range(0, n_out):
cols.append(df.shift(-i))
if i == 0:
names += [('var%d(t)' % (j + 1)) for j in range(n_vars)]
else:
names += [('var%d(t + %d)' % (j + 1, i)) for j in range(n_vars)]
# concat agg的列数=18*属性个数，行数不变，列的名称 是names里面存的var1(t-10)……var5(t-1) 因为我只test五个属性而已。
agg = concat(cols, axis = 1)
agg.columns = names
# dropnan 把含有nan的行都去掉了？去掉十八行
if dropnan:
agg.dropna(inplace = True)
return agg
#
第三个函数
# Remove useless columns
#刚刚算过index_col = 18 * 8
reframed.drop(reframed.columns[[index_col+1,index_col+2,index_col+3,index_col+4,index_col+5,index_col+6,index_col+7]], axis = 1, inplace = True)
#变成38521 240了？？？？？为什么要删掉这七个呢？
为什么非要转化为DataFrame呢
第四部分
# save results
c_pop2rmse = {} #{}的话是一个字典吧 那就是Key-Value键值对
step_param = []
step_fitness = []
最后的函数
# let's begin 20个epoch就是20轮
search_best_attention_rate(20)
def search_best_attention_rate(max_step):
step = 0
while (step != max_step):
print 'Epoch:',step
#每一轮的工作：
# initialize
if step == 0:
#新的函数get_first_param，得到value应该 len=72
value = get_first_param(36,18,6)
#这个pop=value[0]指的是前面一半 01序列（维度有36）
pop = value[0]
# select
selected = select(pop,6,step)
# reconstruct
pop = pop_reconstruct(selected[0],36)
# deeper search
step += 1
# Initialization parameter population
#pop_size=36（why？）, param_num=18（和时间片一样？），encode_length=6（why？）
#返回一个维度为2的list，前一半（维度为36）是基因，后一半（36）是小数
def get_first_param(pop_size, param_num, encode_length):
#first_pop出来了一个size=36的list（像基因编码一样的01序列）
first_pop = get_first_pop(pop_size, param_num, encode_length)
param = []
for each in first_pop:
#对每一条基因（18*6）进行：
#param_num=18, length=6
#每次都得到一个len=18的list（里面是小数），那么最终param就有36个这样的list
param.append(get_param(each,param_num,encode_length))
result = []
result.append(first_pop)
result.append(param)
return result
#Initialize random population
#pop_size=36, param_num=18, encode_length=6
#返回了一个维度为36的list
#每个维度代表一条基因？？是18*6位的 每一位数都是随机产生的哈？这也过于随机了吧
def get_first_pop(pop_size, param_num, encode_length):
pop = []
for i in range(pop_size):
individual = []
for i in range(param_num * encode_length):
#为什么是0-9呢？？？？
temp = random.randint(0,9)
if temp > 4:
individual.append(1)
else:
individual.append(0)
pop.append(individual)
return pop
# Decoding parameter combination
#对每条基因操作：(基因，18，6)
#返回[0.38, 0.13, 0.59, 0.7, 0.32, 0.76, 0.29, 0.62, 0.94, 0.54, 0.13, 0.01, 1.0, 0.83, 0.73, 0.21, 0.43, 0.17]
#对啊六个单位算一次，最后出来list里面有18个元
def get_param(individual_code,param_num, encode_length):
param = []
for i in range(param_num):
#[i*encode_length:(i+1)*encode_length]就是一个分块吧长度为一个length6
param.append(encode(individual_code[i*encode_length:(i+1)*encode_length]))
return param
# Decoding parameter
#这个individual code就是[0,0,1,1,0,1]这样的 只6位
#return一个小数？代表什么？
def encode(individual_code):
#temp就变成 ['0', '0', '1', '1', '0', '1']
temp = [str(each) for each in individual_code]
# normalization
#这里是二进制转十进制了！！变成13，但是/63的理由是???
result = round(int(''.join(temp),2)/63,2)
# exception handling
if result == 0.0:
result += 0.01
return result
# select
def select(pop,n_selected,step):
group_pop = pop2group(pop,n_selected)
fitness_selected = []
pop_selected = []
c1 = 0
for each_group in group_pop:
fit_temp = []
c1 += 1
c2 = 0
for each in each_group:
c2 += 1
print '----------------------------------------------------------'
print 'Step:',step,'-',c1,'-',c2
c_pop = c_pop2str(each)
if c_pop2rmse.has_key(c_pop):
fit_temp.append(c_pop2rmse[c_pop])
print 'Get RMSE from Hash...'
else:
rmse = get_rmse(get_param(each,18,6),reframed)
fit_temp.append(rmse)
c_pop2rmse[c_pop] = rmse
pop_selected.append(each_group[fit_temp.index(min(fit_temp))])
fitness_selected.append(min(fit_temp))
selected = []
selected.append(pop_selected)
selected.append(fitness_selected)
return selected
# Population grouping
def pop2group(pop,group_num):
#random.sample(population, k) Return a k length list of unique elements chosen from the population sequence. Used for random sampling without replacement.
#所以group_index是长度36 每个数字都不同的list
group_index = random.sample(range(0,group_num*6),group_num*6)
group_pop = []
for i in range(group_num):
#temp_index就是把group_index按六个分组 每次记录一组
temp_index = group_index[i*group_num:(i+1)*group_num]
temp_pop = []
for each in temp_index:
#pop是value[0]，就是那个维度为36的，像随机组合一样
#比方说temp_index[0]=[27, 13, 2, 21, 14, 10]
#那么temp_pop就是一直append pop[27],pop[13]……
temp_pop.append(pop[each])
group_pop.append(temp_pop)
return group_pop #len(group_pop)=6
#转成字符串罢了
def c_pop2str(c_pop):
temp = [str(each) for each in c_pop]
key = ''.join(temp)
return key
def get_rmse(param,reframed):
网友评论