#!/usr/bin/python
#-*-coding:utf-8 -*-
# crawl.py
import urllib
import re
def getHtml(url):
    page = urllib.urlopen(url)
    html = page.read()
    return html
def getImg(html):
    reg = r'src="(.+?\.png)" class'
    reg_time = r'<h4>更新时间 (.+?)</h4>'
    imgre = re.compile(reg)
    titlere = re.compile(reg_time)
    imgurl = re.findall(imgre,html)[0]
    title = re.findall(titlere, html)[0][0:13]
    urllib.urlretrieve(imgurl,'./aqi/%s.png' %title)
def getaqi(html, file):
    reg = r'aqi-bg aqi-level-(.+?)\">(.+?)</span>'
    reg_time = r'label label-info\">(.+?)发布</span>'
    aqire = re.compile(reg)
    timere = re.compile(reg_time)
    aqiurl = re.findall(aqire,html)[0][1]
    index = aqiurl.split(" ")[0]
    quality = aqiurl.split(" ")[1]
    time = re.findall(timere, html)[0].replace("年","-").replace("月","-").replace("日","")
    with open(file, 'r') as f:
        lines = f.readlines()
        last_line = lines[-1]
    if (last_line[0:16] != time):
        with open(file, "a") as f:
            f.write('\n' + time + '\t' + index + '\t' + quality)
if __name__ == '__main__':
    #get img
    htmlimg = getHtml("http://www.air-level.com/")
    getImg(htmlimg)
    #get aqi
    cityarr = ("shanghai","beijing","hangzhou","zhuhai","shenzhen","guangzhou","chengdu","haerbin","suzhou","xiamen")
    for i in cityarr:
        htmlaqi = getHtml("http://www.air-level.com/air/%s/" %i)
        getaqi(htmlaqi, "./aqi/%s" %i)

import pandas as pd
import numpy as np
import matplotlib.pyplot as plt
import seaborn as sns
%matplotlib inline

city_lst = ["beijing", "chengdu", "guangzhou", "haerbin", "hangzhou", "shanghai", "shenzhen", "suzhou", "xiamen", "zhuhai"]

df_lst = []
for city in city_lst:
    tmp = pd.read_table(city, names = ["tm", "aqi_" + city, "lv_" + city])
    tmp["tm"] = pd.to_datetime(tmp["tm"].apply(lambda x: x + ":00"))
    df_lst.append(tmp)
timeIndex = pd.date_range("2017-01-07 00:00", "2018-01-06 23:00", freq="H")
timeIndex = timeIndex.to_series().to_frame().reset_index(drop = True)
timeIndex.columns = ["tm"]
df = pd.merge(timeIndex, df_lst[0], how = 'left', on = 'tm')
for i in range(1, len(city_lst)):
    df = pd.merge(df, df_lst[i], how = 'left', on = 'tm')

# hour to day (daily mean)
def day_scale(df):
    df_scale = pd.DataFrame()
    df["date"] = df.tm.dt.date
    df_scale["date"] = df["date"].unique()
    for col in [col for col in df.columns.tolist() if "aqi" in col]:
        df_scale[col] = df.groupby(["date"])[col].mean().reset_index()[col]
    return df_scale

# hour to month (monthly mean)
def month_scale(df):
    df_scale = pd.DataFrame()
    df["month"] = df.index.map(lambda x: str(int(x / df.shape[0] * 12) + 1))
    df_scale["month"] = df["month"].unique()
    for col in [col for col in df.columns.tolist() if "aqi" in col]:
        df_scale[col] = df.groupby(["month"])[col].mean().reset_index()[col]
    return df_scale

# hour scale
plt.figure(figsize=[20,10])
for city in city_lst:
    plt.plot(df["tm"], df["aqi_" + city])
plt.legend(prop={'size':16})

# day scale
plt.figure(figsize=[20,10])
for city in city_lst:
    plt.plot(day_scale(df)["date"], day_scale(df)["aqi_" + city])
plt.legend(prop={'size':16})

# month scale
plt.figure(figsize=[20,10])
for city in city_lst:
    plt.plot(month_scale(df)["month"], month_scale(df)["aqi_" + city])
plt.legend(prop={'size':16})

# Moving Average
df_day = day_scale(df)
df_day.fillna(df_day.median(axis = 0), inplace=True) #should be no none value when using moving average method
plt.figure(figsize=[20,10])
plt.title("30 days moving average", fontsize = 18)
for city in city_lst:
    plt.plot(df_day["date"], df_day["aqi_" + city].to_frame().rolling(30).mean())
plt.legend(city_lst, prop = {'size':16})
plt.figure(figsize=[20,10])
plt.title("60 days moving average", fontsize = 18)
for city in city_lst:
    plt.plot(df_day["date"], df_day["aqi_" + city].to_frame().rolling(60).mean())
plt.legend(city_lst, prop = {'size':16})

plt.figure(figsize=[20,10])
sns.boxplot(df[[col for col in df.columns if "aqi" in col]])
plt.ylim([0,200])
plt.xticks(fontsize = 16)

lvIndex = pd.DataFrame(df.lv_beijing.dropna().unique()).reset_index(drop = True)
lvIndex.columns = ["lvIndex"]

df_lv = df["lv_" + city_lst[0]].value_counts().reset_index()
for i in range(1, len(city_lst)):
    df_lv = pd.merge(df_lv, df["lv_" + city_lst[i]].value_counts().reset_index(), how = 'left', on = 'index')
df_lv = df_lv.fillna(0)
columns = df_lv["index"].map({"优":"lv_0", "良":"lv_1", "轻度污染":"lv_2", "中度污染":"lv_3", "重度污染":"lv_4", "严重污染":"lv_5", "极度污染":"lv_6"})
df_lv = df_lv.transpose().drop(["index"])
df_lv.columns = columns
df_lv.plot(kind = 'bar', stacked = True, figsize = [20,10], fontsize = 16)

import numpy as np
import pandas as pd
import keras.backend as K
from keras import layers
from keras.layers import Dense
from keras.optimizers import Adam
from keras.layers import Input, Embedding, Reshape, Add
from keras.layers import Flatten, merge, Lambda
from keras.models import Model
from keras.utils.vis_utils import plot_model
from sklearn.preprocessing import OneHotEncoder, StandardScaler
from sklearn.metrics import accuracy_score
import random
# similar to https://github.com/jrzaurin/Wide-and-Deep-Keras/blob/master/wide_and_deep_keras.py
def feature_generate(data):
    data, label, cate_columns, cont_columns = preprocessing(data)
    embeddings_tensors = []
    continuous_tensors = []
    for ec in cate_columns:
        layer_name = ec + '_inp'
        # For categorical features, we em-bed the features in dense vectors of dimension 6×(category cardinality)**(1/4)
        embed_dim = data[ec].nunique() if int(6 * np.power(data[ec].nunique(), 1/4)) > data[ec].nunique() \
            else int(6 * np.power(data[ec].nunique(), 1/4))
        t_inp, t_build = embedding_input(layer_name, data[ec].nunique(), embed_dim)
        embeddings_tensors.append((t_inp, t_build))
        del(t_inp, t_build)
    for cc in cont_columns:
        layer_name = cc + '_in'
        t_inp, t_build = continous_input(layer_name)
        continuous_tensors.append((t_inp, t_build))
        del(t_inp, t_build)
    inp_layer =  [et[0] for et in embeddings_tensors]
    inp_layer += [ct[0] for ct in continuous_tensors]
    inp_embed =  [et[1] for et in embeddings_tensors]
    inp_embed += [ct[1] for ct in continuous_tensors]
    return data, label, inp_layer, inp_embed
def embedding_input(name, n_in, n_out):
    inp = Input(shape = (1, ), dtype = 'int64', name = name)
    return inp, Embedding(n_in, n_out, input_length = 1)(inp)
def continous_input(name):
    inp = Input(shape=(1, ), dtype = 'float32', name = name)
    return inp, Reshape((1, 1))(inp)
# The optimal hyperparameter settings were 8 cross layers of size 54 and 6 deep layers of size 292 for DCN
# Embed "Soil_Type" column (embedding dim == 15), we have 8 cross layers of size 29   
def fit(inp_layer, inp_embed, X, y):
    #inp_layer, inp_embed = feature_generate(X, cate_columns, cont_columns)
    input = merge(inp_embed, mode = 'concat')
    # deep layer
    for i in range(6):
        if i == 0:
            deep = Dense(272, activation='relu')(Flatten()(input))
        else:
            deep = Dense(272, activation='relu')(deep)
    # cross layer
    cross = CrossLayer(output_dim = input.shape[2].value, num_layer = 8, name = "cross_layer")(input)
    #concat both layers
    output = merge([deep, cross], mode = 'concat')
    output = Dense(y.shape[1], activation = 'softmax')(output)
    model = Model(inp_layer, output) 
    print(model.summary())
    plot_model(model, to_file = 'model.png', show_shapes = True)
    model.compile(Adam(0.01), loss = 'categorical_crossentropy', metrics = ["accuracy"])
    model.fit([X[c] for c in X.columns], y, batch_size = 256, epochs = 10)
    return model
def evaluate(X, y, model):
    y_pred = model.predict([X[c] for c in X.columns])
    acc = np.sum(np.argmax(y_pred, 1) == np.argmax(y, 1)) / y.shape[0]
    print("Accuracy: ", acc)
# https://keras.io/layers/writing-your-own-keras-layers/
class CrossLayer(layers.Layer):
    def __init__(self, output_dim, num_layer, **kwargs):
        self.output_dim = output_dim
        self.num_layer = num_layer
        super(CrossLayer, self).__init__(**kwargs)
    def build(self, input_shape):
        self.input_dim = input_shape[2]
        self.W = []
        self.bias = []
        for i in range(self.num_layer):
            self.W.append(self.add_weight(shape = [1, self.input_dim], initializer = 'glorot_uniform', name = 'w_' + str(i), trainable = True))
            self.bias.append(self.add_weight(shape = [1, self.input_dim], initializer = 'zeros', name = 'b_' + str(i), trainable = True))
        self.built = True
    def call(self, input):
        for i in range(self.num_layer):
            if i == 0:
                cross = Lambda(lambda x: Add()([K.sum(self.W[i] * K.batch_dot(K.reshape(x, (-1, self.input_dim, 1)), x), 1, keepdims = True), self.bias[i], x]))(input)
            else:
                cross = Lambda(lambda x: Add()([K.sum(self.W[i] * K.batch_dot(K.reshape(x, (-1, self.input_dim, 1)), input), 1, keepdims = True), self.bias[i], input]))(cross)
        return Flatten()(cross)
    def compute_output_shape(self, input_shape):
        return (None, self.output_dim)
# modify the embedding columns here
def preprocessing(data):
    # inverse transform one-hot to continuous column
    df_onehot = data[[col for col in data.columns.tolist() if "Soil_Type" in col]]
    #for i in df_onehot.columns.tolist():
    #    if df_onehot[i].sum() == 0:
    #        del df_onehot[i]
    data["Soil"] = df_onehot.dot(np.array(range(df_onehot.columns.size))).astype(int)
    data.drop([col for col in data.columns.tolist() if "Soil_Type" in col], axis = 1, inplace = True)
    label = np.array(OneHotEncoder().fit_transform(data["Cover_Type"].reshape(-1, 1)).todense())
    del data["Cover_Type"]
    cate_columns = ["Soil"]
    cont_columns = [col for col in data.columns if col != "Soil"]
    # Feature normilization
    scaler = StandardScaler()
    data_cont = pd.DataFrame(scaler.fit_transform(data[cont_columns]), columns = cont_columns)
    data_cate = data[cate_columns]
    data = pd.concat([data_cate, data_cont], axis = 1)
    return data, label, cate_columns, cont_columns
if __name__ == "__main__":
    # data download from https://www.kaggle.com/uciml/forest-cover-type-dataset/data
    data = pd.read_csv("./data/covtype.csv")
    X, y, inp_layer, inp_embed = feature_generate(data)
    
    #random split train and test by 9:1
    train_index = random.sample(range(X.shape[0]), int(X.shape[0] * 0.9))
    test_index = list(set(range(X.shape[0])) - set(train_index))
    model = fit(inp_layer, inp_embed, X.iloc[train_index], y[train_index, :])
    evaluate(X.iloc[test_index], y[test_index, :], model)

def _init_graph(self):
    self.graph = tf.Graph()
    with self.graph.as_default(): 
        # Input data.
        self.train_features = tf.placeholder(tf.int32, shape=[None, None], name="train_features_afm")  # None * features_M
        self.train_labels = tf.placeholder(tf.float32, shape=[None, 1], name="train_labels_afm")  # None * 1
        self.dropout_keep = tf.placeholder(tf.float32, shape=[None], name="dropout_keep_afm")
        # Variables.
        self.weights = self._initialize_weights()
        # Model.
         # _________ Embedding part _____________
        # data为libsvm格式，且非none特征共有M‘个，且特征值均为1。data中每个feature都对应一个K维embedding
        self.nonzero_embeddings = tf.nn.embedding_lookup(self.weights['feature_embeddings'], self.train_features) # None * M' * K
        
        # 交叉项embedding layer生成，对应equation(2)
        element_wise_product_list = []
        count = 0
        for i in range(0, self.valid_dimension):
            for j in range(i+1, self.valid_dimension):
               element_wise_product_list.append(tf.multiply(self.nonzero_embeddings[:,i,:], self.nonzero_embeddings[:,j,:]))
                count += 1
        self.element_wise_product = tf.stack(element_wise_product_list) # (M'*(M'-1))/2 * None * K
        self.element_wise_product = tf.transpose(self.element_wise_product, perm=[1,0,2], name="element_wise_product") # None * (M'*(M'-1))/2 * K
        
        # _________ MLP Layer / attention part _____________
        # self.attention == True时，模型为Attention FM;
        # self.attention == False时，就退化为Neural FM
        num_interactions = self.valid_dimension*(self.valid_dimension-1)/2
        if self.attention:
            # 对应equation(4)-1
            self.attention_mul = tf.reshape(tf.matmul(tf.reshape(self.element_wise_product, shape=[-1, self.hidden_factor[1]]),self.weights['attention_W']), shape=[-1, num_interactions, self.hidden_factor[0]])
            self.attention_exp = tf.exp(tf.reduce_sum(tf.multiply(self.weights['attention_p'], tf.nn.relu(self.attention_mul + self.weights['attention_b'])), 2, keep_dims=True)) # None * (M'*(M'-1)) * 1
            self.attention_sum = tf.reduce_sum(self.attention_exp, 1, keep_dims=True) # None * 1 * 1
            # 对应equation(4)-2
            self.attention_out = tf.div(self.attention_exp, self.attention_sum, name="attention_out") # None * (M'*(M'-1)) * 1
            # 在attention部分引入dropout
            self.attention_out = tf.nn.dropout(self.attention_out, self.dropout_keep[0]) # dropout
            self.AFM = tf.reduce_sum(tf.multiply(self.attention_out, self.element_wise_product), 1, name="afm") # None * K
        else:              # Neural FM
            self.AFM = tf.reduce_sum(self.element_wise_product, 1, name="afm") # None * K
        
        # 在全连接（映射）部分二次引入dropout
        self.AFM = tf.nn.dropout(self.AFM, self.dropout_keep[1]) # dropout
        # _________ out _____________
        self.prediction = tf.matmul(self.AFM, self.weights['prediction']) # None * 1
        # 引入传统FM中的一阶项和常数项
        Bilinear = tf.reduce_sum(self.prediction, 1, keep_dims=True)  # None * 1
        self.Feature_bias = tf.reduce_sum(tf.nn.embedding_lookup(self.weights['feature_bias'], self.train_features) , 1)  # None * 1
        Bias = self.weights['bias'] * tf.ones_like(self.train_labels)  # None * 1
        self.out = tf.add_n([Bilinear, self.Feature_bias, Bias], name="out_afm")  # None * 1
        # Compute the loss.
        # 在loss中加入L2正则项
        self.loss = tf.nn.l2_loss(tf.subtract(self.train_labels, self.out)) + tf.contrib.layers.l2_regularizer(self.lamda_attention)(self.weights['attention_W'])  # regulizer
        # Optimizer.
        # 传统FM为SGD方式迭代训练，可能会导致训练不充分的情况。Ada系列的迭代方式learning rate可变，会一定程度上缓解这个现象
        if self.optimizer_type == 'AdamOptimizer':
            self.optimizer = tf.train.AdamOptimizer(learning_rate=self.learning_rate, beta1=0.9, beta2=0.999, epsilon=1e-8).minimize(self.loss)
        elif self.optimizer_type == 'AdagradOptimizer':
            self.optimizer = tf.train.AdagradOptimizer(learning_rate=self.learning_rate, initial_accumulator_value=1e-8).minimize(self.loss)
        else:
            self.optimizer = tf.train.GradientDescentOptimizer(learning_rate=self.learning_rate).minimize(self.loss)
        # init
        self.saver = tf.train.Saver()
        init = tf.global_variables_initializer()
        self.sess = self._init_session()
        self.sess.run(init)

node1 = tf.constant(3.0, tf.float32)
node2 = tf.constant(4.0) # also tf.float32 implicitly
print(node1, node2)
#Output: Tensor("Const:0", shape=(), dtype=float32) Tensor("Const_1:0", shape=(), dtype=float32)
sess = tf.Session()
print(sess.run([node1, node2]))
#Output:[3.0, 4.0]
node3 = tf.add(node1, node2)
print("node3: ", node3)
print("sess.run(node3): ",sess.run(node3))
#Output:7.0

a = tf.placeholder(tf.float32)
b = tf.placeholder(tf.float32)
adder_node = a + b  # + provides a shortcut for tf.add(a, b)
print(sess.run(adder_node, feed_dict = {a: 3, b:4.5}))
#Output:7.5
print(sess.run(adder_node, feed_dict = {a: [1,3], b: [2, 4]}))
#Output:[ 3.  7.]
add_and_triple = adder_node * 3.
print(sess.run(add_and_triple, feed_dict = {a: 3, b:4.5}))
#Output:22.5

W = tf.Variable([.3], tf.float32) #Trainable param
b = tf.Variable([-.3], tf.float32) #Trainable param
x = tf.placeholder(tf.float32) #Input placeholder
y = tf.placeholder(tf.float32) #Input placeholder
linear_model = W * x + b # Linear Regression
squared_deltas = tf.square(linear_model - y) #Define square loss
loss = tf.reduce_sum(squared_deltas) #Add loss on all samples
init = tf.global_variables_initializer() # You must explicitly initilize the variables
sess.run(init) # Until we call sess.run, the variables are uninitialized
print(sess.run(loss, {x:[1,2,3,4], y:[0,-1,-2,-3]}))
#Output:23.66

optimizer = tf.train.GradientDescentOptimizer(0.01) # define gradient descent method
train = optimizer.minimize(loss) # minize loss using gradient descent
sess.run(init) # reset values to incorrect defaults.
for i in range(1000): # run gradient descent for 1000 steps
  sess.run(train, {x:[1,2,3,4], y:[0,-1,-2,-3]})
print(sess.run([W, b]))
#Output:[array([-0.9999969], dtype=float32), array([ 0.99999082],dtype=float32)]

def read_my_file_format(filename_queue):
  reader = tf.SomeReader() # define reader
  key, record_string = reader.read(filename_queue) # read file from file_queue using reader, each execution of read reads a single line from the file
  example, label = tf.some_decoder(record_string) # decode file
  processed_example = some_processing(example) # do some preprocessing
  return processed_example, label
def input_pipeline(filenames, batch_size, num_epochs=None):
  filename_queue = tf.train.string_input_producer(
      filenames, num_epochs=num_epochs, shuffle=True)
  example, label = read_my_file_format(filename_queue)
  min_after_dequeue = 10000 # define how big a buffer we will randomly sample from
  capacity = min_after_dequeue + 3 * batch_size # larger than min_after_dequeue
  example_batch, label_batch = tf.train.shuffle_batch(
      [example, label], batch_size=batch_size, capacity=capacity,
      min_after_dequeue=min_after_dequeue) # make batch sample
  return example_batch, label_batch

import pandas as pd
import tensorflow as tf
import tensorflow.contrib.learn as tf_learn
import tensorflow.contrib.layers as tf_layers
from sklearn.metrics import accuracy_score
from sklearn.preprocessing import LabelEncoder
from sklearn.cross_validation import train_test_split
import os
import numpy as np
from sklearn.metrics import roc_auc_score
from sklearn.preprocessing import StandardScaler
from feat import CONTINUOUS_COLUMNS
from feat import CATEGORICAL_COLUMNS
from feat import COLUMNS
def add_columns(x):
    return ':'.join(x)
# Define the column names for the data sets.
LABEL_COLUMN = 'target'
#second order
CROSSED_COLUMNS = []
for i in range(len(CATEGORICAL_COLUMNS) -1):
  for j in range(i+1, len(CATEGORICAL_COLUMNS)):
     CROSSED_COLUMNS.append([CATEGORICAL_COLUMNS[i], CATEGORICAL_COLUMNS[j]])
CATEGORICAL_COLUMNS_DNN = CATEGORICAL_COLUMNS[:]
CATEGORICAL_COLUMNS += map(add_columns, CROSSED_COLUMNS)
CATEGORICAL_ID_COLUMNS = [col + '_ids' for col in CATEGORICAL_COLUMNS]
HIDDEN_UNITS = [512, 512, 512]
CATEGORICAL_EMBED_SIZE = 10
LABEL_ENCODERS = {}
def pandas_input_fn(X, y=None, batch_size=1024, num_epochs=None):
    def input_fn():
        if y is not None:
            X['target'] = y
        queue = tf_learn.dataframe.queues.feeding_functions.enqueue_data(
            X, 1000, shuffle=num_epochs is None, num_epochs=num_epochs)
        if num_epochs is None:
            features = queue.dequeue_many(batch_size)
        else:
            features = queue.dequeue_up_to(batch_size)
        features = dict(zip(['index'] + list(X.columns), features))
        if y is not None:
            target = features.pop('target')
            return features, target
        return features
    return input_fn
def encode_categorical_cross(df):
    global LABEL_ENCODERS
    for col in CATEGORICAL_COLUMNS:
        if ":" in col:
            df[col] = df[col.split(":")[0]].fillna(-1).astype(str) + ":" + df[col.split(":")[1]].fillna(-1).astype(str)
        else:
            df[col] = df[col].fillna(-1).astype(str)
        encoder = LabelEncoder().fit(df[col])
        df[col + '_ids'] = encoder.transform(df[col])
        LABEL_ENCODERS[col] = encoder
    for col in CATEGORICAL_COLUMNS:
        df.pop(col)
    return df, LABEL_ENCODERS
def process_input_df(df):
    df, label_encoders = encode_categorical_cross(df)
	for col in CATEGORICAL_COLUMNS:
    	y = df.pop(LABEL_COLUMN)
    	X = df[CATEGORICAL_ID_COLUMNS + CONTINUOUS_COLUMNS].fillna(0)
    return X, y
def wide_and_deep(features, target, hidden_units=HIDDEN_UNITS):
    global LABEL_ENCODERS
    target = tf.one_hot(target, 2, 1.0, 0.0)
    # DNN
    final_features_nn = [tf.expand_dims(tf.cast(features[col], tf.float32), 1) for
                      col in CONTINUOUS_COLUMNS]
    # Embed categorical variables into distributed representation.
    for col in CATEGORICAL_COLUMNS_DNN:
        feature_tmp = tf_learn.ops.categorical_variable(
            features[col + '_ids'],
            len(LABEL_ENCODERS[col].classes_),
            embedding_size=CATEGORICAL_EMBED_SIZE,
            name=col)
        final_features_nn.append(feature_tmp)
    # Concatenate all features into one vector.
    features_nn = tf.concat(1, final_features_nn)
    logits_nn = tf_layers.stack(features_nn,
                             tf_layers.fully_connected,
                             stack_args=hidden_units,
                             activation_fn=tf.nn.relu)
    # LR
    final_features_lr = [tf.expand_dims(tf.cast(features[col], tf.float32), 1) for
                      col in CONTINUOUS_COLUMNS]
    for col in CATEGORICAL_COLUMNS:
        final_features_lr.append(tf.one_hot(features[col + '_ids'],
            len(LABEL_ENCODERS[col].classes_),
            on_value = 1.0,
            off_value = 0.0))
    logits_lr = tf_layers.stack(tf.concat(1, final_features_lr),
                             tf_layers.fully_connected,
                             stack_args=[1],
                             activation_fn=None)
    # add logits
    logits = logits_lr + logits_nn
    prediction, loss = tf_learn.models.logistic_regression(logits, target)
    train_op = tf_layers.optimize_loss(loss,
                                       tf.contrib.framework.get_global_step(),
                                       optimizer='Adam',
                                       learning_rate=0.001)
    return prediction[:,1], loss, train_op
def train(X, y, steps=100):
    print("model dir: ", model_dir)
    classifier = tf_learn.Estimator(model_fn=wide_and_deep, model_dir=model_dir)
    classifier.fit(input_fn=pandas_input_fn(X, y), steps=steps)
    return classifier
def predict(classifier, X):
    return list(classifier.predict(input_fn=pandas_input_fn(X, num_epochs=1),
                                   as_iterable=True))
if __name__ == '__main__':
    model_dir = "./wnd"
    os.system("rm -rf ./wnd")
    trainFile = 'train.csv'
    testFile = 'test.csv'
    data_train = pd.read_csv(trainFile, names=COLUMNS)  # LOAD DATA
    data_test = pd.read_csv(testFile, names=COLUMNS)  # LOAD DATA
    train_size = data_train.shape[0]
    X_train, y_train = process_input_df(data_train)
    X_test, y_test = process_input_df(data_test)
    # data scale
    data_continuous = pd.concat([X_train[CONTINUOUS_COLUMNS], X_test[CONTINUOUS_COLUMNS]])
    scaler = StandardScaler()
    data_continuous_scale = scaler.fit_transform(data_continuous)
    X_train[CONTINUOUS_COLUMNS] = pd.DataFrame(data_continuous_scale[:train_size])
    X_test[CONTINUOUS_COLUMNS] = pd.DataFrame(data_continuous_scale[train_size:])
    classifier = train(X_train, y_train, steps=5000)
    pred = predict(classifier, X_test)
    print("auc", roc_auc_score(y_test, np.array(pred)))