import pandas as pd

import numpy as np

import math

from sklearn.utils import shuffle

from sklearn.metrics import confusion_matrix

from sklearn.metrics import f1_score

filePath = "E:assignmentdata{}.csv"

folds = 5

iterations = 1000

lr = 0.0005

coeff = list()

def main():

infogainexercise()

for i in range(1, 57):

logreg(i)

print(coeff)

print("length of final ", len(coeff))

dfout =pd.DataFrame(coeff)

print(dfout)

dfout.to_csv(filePath.format("coeff"), index=False, header=None)

def sigmoid(z):

return 1 / (1 + np.exp(-z))
def loss_fn(h, y):

return (-y * np.log(h) - (1 - y) * np.log(1 - h)).mean()

def predict(X, theta):

threshold = 0.5

prob = sigmoid(np.dot(X, theta))

return [x for x in map(lambda x: 1 if x else 0, prob >= threshold)]

def logreg(k):

df = pd.read_csv(filePath.format(k), header=None)

sample = math.floor(len(df) / folds)

weights = list()

loss = list()

accuracy = list()

fscore = list()

print("processing file {}".format(k), ">>>>>>>>>>>>>")

for f in range(1, folds + 1):

shuffledata = shuffle(df)

test = shuffledata[:sample]

train = shuffledata[sample:]

train_X =train.iloc[:, 0:20]

# add intercept to train data

train_X["intercept"] = 1

train_Y = train[20].gt(0).astype(int)
# print(train_X.shape)

test_X =test.iloc[:, 0:20]

# add intercept to test data

test_X["intercept"] = 1

test_Y = test[20].gt(0).astype(int)

theta = np.zeros(train_X.shape[1])

for i in range(iterations):

z = np.dot(train_X, theta)

h = sigmoid(z)

gradient = np.dot(train_X.T, (h -train_Y)) / train_Y.size

theta -= lr * gradient

if i % iterations == 0:

z = np.dot(train_X, theta)

h = sigmoid(z)

# loss

loss.append(loss_fn(h,train_Y))

# weights

weights.append([x for x in reversed(theta)])

# predictions on test data

y_hat = predict(test_X, theta)

# accuracy on test data

 accuracy.append((y_hat ==test_Y).mean())

# confusion matrix

cf =confusion_matrix(test_Y, y_hat)

# f1 score

fscore.append(f1_score(test_Y,y_hat))

# print("predictions",y_hat)

print("weights", weights)

print("accuracy", accuracy)

print("f1 score", fscore)

# pick best weights based on max f1 measure

# if max f1 is 0, then pick max accuracy

maxpos = 0

if max(fscore) != 0:

maxpos =fscore.index(max(fscore))

else:

maxpos =accuracy.index(max(accuracy))

print("max value::", maxpos, fscore[maxpos], accuracy[maxpos])

x1 = weights[maxpos]

x1.insert(21, fscore[maxpos])

x1.insert(22, accuracy[maxpos])

# print(">>>>>>>>>>>>>>>>>>>>>>", x1)

coeff.append(x1)

return coeff
def infogainexercise():

infogainfinal = []

for i in range(1, 57):

print("file processed {}".format(i))

df = pd.read_csv(filePath.format(i), header=None)

features = df.loc[:, :19]

labels = df[20].gt(0).astype(int)

infogain = []

# print([x for x in df.columns])

for col in features.columns:

# ftinfo = []

threshold = np.mean(df[col])

features["new"] = features[col].gt(threshold).astype(int)

df1 = pd.DataFrame(list(zip(features["new"], labels)), columns=["x",

"y"])

tot = df1.count()[0]

# print("total rows:", tot)

infogain.append(infogain_fn(df1))

# print(df)

# infogain.append(ftinfo)

infogainfinal.append(infogain)

dfout =pd.DataFrame(infogainfinal)

print(dfout)

dfout.to_csv(filePath.format("infogain"), index=False, header=None)

def infogain_fn(df):

# print(df)
tot = df.count()[0]

# calcuate entropy of child

c00 = df[(df["x"] == 0) & (df["y"] == 0)].count()[0]

c01 = df[(df["x"] == 0) & (df["y"] == 1)].count()[0]

t0 = c00 + c01

c10 = df[(df["x"] == 1) & (df["y"] == 0)].count()[0]

c11 = df[(df["x"] == 1) & (df["y"] == 1)].count()[0]

t1 = c10 + c11

# print(c10, c11, c00, c01)

ig00 = 0

if c00 != 0:

ig00 = -1 * (c00 / t0) * math.log2(c00 / t0)

ig01 = 0

if c01 != 0:

ig01 = -1 * (c01 / t0) * math.log2(c01 / t0)

ig10 = 0

if c10 != 0:

ig1 = -1 * (c10 / t1) * math.log2(c10 / t1)

ig11 = 0

if c11 != 0:

ig11 = -1 * (c11 / t1) * math.log2(c11 / t1)

ig0 = ig00 + ig01

ig1 = ig10 + ig11

 entchild = (t0 / tot) * ig0 + (t1 / tot) * ig1

# calculate entropy of parent

pc0 = df[(df["y"] == 0)].count()[0]

pc1 = df[(df["y"] == 1)].count()[0]

e0 = 0

if pc0 != 0:

e0 = -1 * (pc0 / tot) * math.log2(pc0 / tot)

e1 = 0

if pc0 != 0:

e1 = -1 * (pc1 / tot) * math.log2(pc1 / tot)

eparent = e0 + e1

return eparent -entchild

if __name__ == "__main__":

main()