Antro turo NN

tfmodel.py

#!/Users/petras/.conda/envs/tensorflow3/bin/python

import tensorflow as tf
import numpy as np
import pandas as pd
import datetime
import time

#####
ITERATIONS = 100
TRAINING_STEPS = 2000
OPTIM = 0.01
REG_PARAM = 5e-6
INCLUDE_DAUG = False
INCLUDE_AKT = False
NORMALIZE = False
LOG = False


df = pd.read_csv('2012_I.csv')
df.loc[df.duplicated(['apygarda', 'partija']), 'partija'] = 'Išsikėlė pats 2'
df.loc[df.duplicated(['apygarda', 'partija']), 'partija'] = 'Išsikėlė pats 3'

df = df[['apygarda', 'partija', 'pct_dalyvavusiu']]
df = df[df.apygarda != '43. Kėdainių']
df = df[df.apygarda != '56. Vilniaus - Šalčininkų']
df = df[df.apygarda != '68. Vilkaviškio']
df = df[df.apygarda != '52. Zarasų - Visagino'] # hmm...

df.pct_dalyvavusiu = df.pct_dalyvavusiu.str.replace(',','.')
df.pct_dalyvavusiu = df.pct_dalyvavusiu.str.rstrip('%')
df.pct_dalyvavusiu = df.pct_dalyvavusiu.astype(float)
df.pct_dalyvavusiu = df.pct_dalyvavusiu / 100

df = df.pivot(index='apygarda', columns='partija', values='pct_dalyvavusiu').fillna(0)

df['Tėvynės sąjunga - Lietuvos krikščionys demokratai'] = df['Tėvynės sąjunga - Lietuvos krikščionys demokratai, išsikėlė pats'] + \
														  df['Tėvynės sąjunga - Lietuvos krikščionys demokratai']
df['Politinė partija „Lietuvos sąrašas“'] = df['Politinė partija „Lietuvos sąrašas“, išsikėlė pats'] + \
											df['Politinė partija „Lietuvos sąrašas“']	
df.drop('Tėvynės sąjunga - Lietuvos krikščionys demokratai, išsikėlė pats', axis=1)		
df.drop('Politinė partija „Lietuvos sąrašas“, išsikėlė pats', axis=1)		

df2 = pd.read_csv('2012_II.csv')
df2 = df2[['apygarda', 'partija', 'viso']]
df2 = df2.pivot(index='apygarda', columns='partija', values='viso').fillna(0)
df2['Tėvynės sąjunga - Lietuvos krikščionys demokratai'] = df2['Tėvynės sąjunga - Lietuvos krikščionys demokratai, išsikėlė pats'] + \
														  df2['Tėvynės sąjunga - Lietuvos krikščionys demokratai']


#df = (df - df.mean()) / (df.max()- df.min())

df['isliko'] = (df.idxmax(axis=1) == df2.idxmax(axis=1)).astype(float)

if(INCLUDE_DAUG):
	df_daug = pd.read_csv('2012_daugiam.csv')
	df_daug = df_daug[['apygarda', 'vardas', 'pct_dalyvavusiu']]
	df_daug = df_daug[df_daug.apygarda != '43. Kėdainių']
	df_daug = df_daug[df_daug.apygarda != '56. Vilniaus - Šalčininkų']
	df_daug = df_daug[df_daug.apygarda != '68. Vilkaviškio']
	df_daug = df_daug[df_daug.apygarda != '52. Zarasų - Visagino'] # hmm...
	df_daug.pct_dalyvavusiu = df_daug.pct_dalyvavusiu.str.replace(',','.')
	df_daug.pct_dalyvavusiu = df_daug.pct_dalyvavusiu.str.rstrip('%')
	df_daug.pct_dalyvavusiu = df_daug.pct_dalyvavusiu.astype(float)
	df_daug.pct_dalyvavusiu = df_daug.pct_dalyvavusiu / 100
	df_daug = df_daug.pivot(index='apygarda', columns='vardas', values='pct_dalyvavusiu').fillna(0)
	df_daug.columns = df_daug.columns + ' daugiamandate'

	df = pd.concat([df, df_daug], axis=1, join="inner")

if(INCLUDE_AKT):
	df_akt = pd.read_csv('2012_aktyvumas.csv', index_col=0)
	df_akt.aktyvumas = df_akt.aktyvumas.astype(float) / 100
	df_akt = df_akt[df_akt.index != '43. Kėdainių']
	df_akt = df_akt[df_akt.index != '56. Vilniaus - Šalčininkų']
	df_akt = df_akt[df_akt.index != '68. Vilkaviškio']
	df_akt = df_akt[df_akt.index != '52. Zarasų - Visagino'] # hmm...

	if(NORMALIZE):
		df_akt = (df_akt - df_akt.mean()) / (df_akt.max()- df_akt.min())

	df = pd.concat([df, df_akt], axis=1)


df3 = pd.read_csv('2016_I.csv')
df3.loc[pd.isnull(df3.partija), 'partija'] = 'Išsikėlė pats'
df3.loc[df3.duplicated(['apygarda', 'partija']), 'partija'] = 'Išsikėlė pats 2'
df3.loc[df3.duplicated(['apygarda', 'partija']), 'partija'] = 'Išsikėlė pats 3'
df3.loc[df3.partija=='Lietuvos laisvės sąjunga (liberalai)', 'partija'] = 'Politinė partija „Sąjunga Taip“'
df3.loc[df3.partija=='Lietuvos lenkų rinkimų akcija-Krikščioniškų šeimų sąjunga', 'partija'] = 'Lietuvos lenkų rinkimų akcija'
df3.loc[df3.partija=='Lietuvos žaliųjų partija', 'partija'] = 'Politinė partija „Lietuvos žaliųjų sąjūdis“'
df3.loc[df3.partija=='Antikorupcinė N. Puteikio ir K. Krivicko koalicija (Lietuvos centro partija, Lietuvos pensininkų partiją)', 'partija'] = 'Lietuvos centro partija'
df3.loc[df3.partija=='Lietuvos liaudies partija', 'partija'] = 'Respublikonų partija'
df3.loc[df3.partija=='S. Buškevičiaus ir Tautininkų koalicija „Prieš korupciją ir skurdą“ (Partija „Jaunoji Lietuva“, Tautininkų sąjunga)', 'partija'] = 'Partija „Jaunoji Lietuva“'
df3.loc[df3.vardas=='ALGIRDAS PALECKIS', 'partija'] = 'Socialistinis liaudies Frontas'

df3.pct_dalyvavusiu = df3.pct_dalyvavusiu.str.replace(',','.')
df3.pct_dalyvavusiu = df3.pct_dalyvavusiu.str.rstrip('%')
df3.pct_dalyvavusiu = df3.pct_dalyvavusiu.astype(float)
df3.pct_dalyvavusiu = df3.pct_dalyvavusiu / 100

df3 = df3.pivot(index='apygarda', columns='partija', values='pct_dalyvavusiu').fillna(0.0)

if(INCLUDE_DAUG):
	df3_daug = pd.read_csv('2016_daugiam.csv')
	df3_daug.loc[df3_daug.vardas=='Lietuvos laisvės sąjunga (liberalai)', 'vardas'] = 'Politinė partija „Sąjunga Taip“'
	df3_daug.loc[df3_daug.vardas=='Lietuvos lenkų rinkimų akcija-Krikščioniškų šeimų sąjunga', 'vardas'] = 'Lietuvos lenkų rinkimų akcija'
	df3_daug.loc[df3_daug.vardas=='Lietuvos žaliųjų partija', 'vardas'] = 'Politinė partija „Lietuvos žaliųjų sąjūdis“'
	df3_daug.loc[df3_daug.vardas=='Antikorupcinė N. Puteikio ir K. Krivicko koalicija (Lietuvos centro partija, Lietuvos pensininkų partiją)', 'vardas'] = 'Nacionalinis susivienijimas „Už Lietuvą Lietuvoje“ (Lietuvos centro partijos, Lietuvos socialdemokratų sąjungos, Tautininkų sąjungos ir Tautos vienybės sąjungos koalicija)'
	df3_daug.loc[df3_daug.vardas=='Lietuvos liaudies partija', 'vardas'] = 'Respublikonų partija'
	df3_daug.loc[df3_daug.vardas=='S. Buškevičiaus ir Tautininkų koalicija „Prieš korupciją ir skurdą“ (Partija „Jaunoji Lietuva“, Tautininkų sąjunga)', 'vardas'] = 'Partija „Jaunoji Lietuva“'
	df3_daug = df3_daug[['apygarda', 'vardas', 'pct_dalyvavusiu']]
	df3_daug.pct_dalyvavusiu = df3_daug.pct_dalyvavusiu.str.replace(',','.')
	df3_daug.pct_dalyvavusiu = df3_daug.pct_dalyvavusiu.str.rstrip('%')
	df3_daug.pct_dalyvavusiu = df3_daug.pct_dalyvavusiu.astype(float)
	df3_daug.pct_dalyvavusiu = df3_daug.pct_dalyvavusiu / 100
	df3_daug = df3_daug.pivot(index='apygarda', columns='vardas', values='pct_dalyvavusiu').fillna(0)
	df3_daug = df3_daug.drop('Politinė partija „Lietuvos sąrašas“', axis=1)
	df3_daug = df3_daug.drop('Politinė partija „Lietuvos žaliųjų sąjūdis“', axis=1)

	df3_daug.columns = df3_daug.columns + ' daugiamandate'
	df3 = pd.concat([df3, df3_daug], axis=1, join="inner")

if(INCLUDE_AKT):
	df3_akt = pd.read_csv('2016_aktyvumas.csv', index_col=0)
	df3_akt.aktyvumas = df3_akt.aktyvumas.astype(float) / 100
	
	if(NORMALIZE):
		df3_akt = (df3_akt - df3_akt.mean()) / (df3_akt.max()- df3_akt.min())

	df3 = pd.concat([df3, df3_akt], axis=1)

df3 = pd.DataFrame(columns=df.columns).append(df3, ignore_index=True).fillna(0)
#df3 = (df3 - df3.mean()) / (df3.max()- df3.min())

df3 = np.asarray(df3.drop('isliko', axis=1).astype(float))

results = np.zeros(shape=(ITERATIONS, 71))

####################
### Tensorflow setup
####################

x = tf.placeholder(tf.float32, [None, df3.shape[1]], name='x')
W = tf.Variable(tf.random_normal([df3.shape[1], 20], stddev=0.3), name='W')
b = tf.Variable(tf.random_normal([20], stddev=0.5), name='b')
true_y = tf.placeholder(tf.float32, [None, 1], name='true_y')

y1 = tf.nn.sigmoid(tf.matmul(x, W) + b)
W1 = tf.Variable(tf.random_normal([20, 10], stddev=0.3), name="W1")
b1 = tf.Variable(tf.random_normal([10], stddev=0.5), name='b1')

y2 = tf.nn.sigmoid(tf.matmul(y1, W1) + b1)
W2 = tf.Variable(tf.random_normal([10, 1], stddev=0.3), name="W2")
b2 = tf.Variable(tf.random_normal([1], stddev=0.5), name="b2")

predicted_y = tf.nn.sigmoid(tf.matmul(y2, W2) + b2)
cost = tf.reduce_mean(-true_y*tf.log(predicted_y+0.0001)-(1-true_y)*tf.log(1-predicted_y+0.0001)) \
	+ tf.reduce_sum(tf.abs(W))*REG_PARAM \
	+ tf.reduce_sum(tf.abs(b))*REG_PARAM \
	+ tf.reduce_sum(tf.abs(W1))*REG_PARAM \
	+ tf.reduce_sum(tf.abs(b1))*REG_PARAM \
	+ tf.reduce_sum(tf.abs(W2))*REG_PARAM \
	+ tf.reduce_sum(tf.abs(b2))*REG_PARAM
	   
train_step = tf.train.AdamOptimizer(OPTIM).minimize(cost)

if(LOG):
	test_cost = tf.scalar_summary("Test cost", cost)
	correct_prediction = tf.equal(tf.greater(predicted_y, 0.5),tf.cast(true_y, tf.bool), name="prediction_check")
	false_positives = tf.logical_and(tf.greater(predicted_y, 0.5), tf.logical_not(tf.cast(true_y, tf.bool)), name="false_pos")
	fp = tf.reduce_sum(tf.cast(false_positives, tf.float32))
	false_negatives = tf.logical_and(tf.less_equal(predicted_y, 0.5), tf.cast(true_y, tf.bool), name="false_neg")
	fn = tf.reduce_sum(tf.cast(false_negatives, tf.float32))
	true_positives = tf.logical_and(tf.greater(predicted_y, 0.5), tf.cast(true_y, tf.bool), name="true_pos")
	tp = tf.reduce_sum(tf.cast(true_positives, tf.float32))
	accuracy = tf.reduce_sum(tf.cast(correct_prediction, tf.float32))/(tf.reduce_sum(tf.cast(correct_prediction, tf.float32))+fp+fn)
	ac_summary = tf.scalar_summary('Accuracy', accuracy)
	precision = tp / (fp + tp)
	tf.scalar_summary("Precision", precision)
	recall = tp / (tp + fn)
	tf.scalar_summary("Recall", recall)
	F1_score = 2*precision*recall / (precision + recall)
	F1_score_summary = tf.scalar_summary("F1_score", F1_score)
	tf.scalar_summary("False positives", fp)
	tf.scalar_summary("False negatives", fn)

init = tf.initialize_all_variables()
if(LOG):
	merged = tf.merge_all_summaries()

# Do the runs and then average the probabilities
################################################
for iteration in range(ITERATIONS):

	print("Iteration: %i"%iteration)

	train=df.sample(frac=0.8)
	test=df.drop(train.index)

	train_y = np.asarray(train.isliko)
	test_y = np.asarray(test.isliko)
	train = np.asarray(train.drop('isliko', axis=1).astype(float))
	test  = np.asarray(test.drop('isliko', axis=1).astype(float))

	train_y = np.reshape(train_y, (train_y.shape[0], 1))
	test_y = np.reshape(test_y, (test_y.shape[0], 1))

	s = tf.Session()
	s.run(init)

	if(LOG):
		summary_writer = tf.train.SummaryWriter('/tmp/basic/'+datetime.datetime.fromtimestamp(time.time()).strftime('%Y-%m-%d_%H:%M:%S')+'_'+str(TRAINING_STEPS)+'_'+str(OPTIM), 
			graph = tf.get_default_graph())

	for i in range(TRAINING_STEPS):
		if(LOG):
			_, c, summary = s.run([train_step, cost, merged], feed_dict={x: train, true_y: train_y})
			summary_writer.add_summary(summary, i)
			if i % 1000 == 0:
				s.run([ac_summary, F1_score_summary, test_cost], feed_dict={x:test, true_y:test_y})
		else:
			_, c = s.run([train_step, cost], feed_dict={x: train, true_y: train_y})

	### Now we have the Neural Network trained, so let's plug the 2016 data and see the outcome
	results[iteration] = s.run([predicted_y], feed_dict={ x: df3 })[0].T

print(results.mean(axis=0))
print((results > 0.5).astype(int).sum(axis=0))