HOw to use$/$include$/$implement non$-$convex optimizer to this code? import tensorflow as tf

import numpy as np

from sklearn.preprocessing import normalize

import matplotlib.pyplot as plt

# parameter zero$\_$one controls, whether the labels are $0,1$ or $-1,1$

def read$\_$parse$\_$data$($zero$\_$one$=$True$)$:

labels $=[]$

data $=[]$

with open$("$ijcnn$1.$txt$")$ as f:

for line in f:

xs $=$ line.split$("")$

h $=[0\mathrm{.}0]*22$

for s in xs$[1$:$]$:

s $=$ s$.$strip$()$

if len$($s$)==0$:

continue

k$,$ v $=$ s$.$split$("$:$")$

h$[$int$($k$)-1]=$ float$($v$)$

data.append$($h$)$

if xs$[0]=="1"$:

labels.append$(1)$

elif zero$\_$one:

labels.append$(0)$

else:

labels.append$(-1)$

return np$.$array$($data$),$ np$.$array$($labels$)$

def prediction$($w$,$ data$)$:

return $1/(1+$np$.$exp$(-$np$.$dot$($data$,$ w$)))$

def logloss$($pred$,$ labels$)$:

pred $=$ np$.$clip$($pred$,1$e$-15,1-1$e$-15)$

Li $=-($labels $*$ np$.$log$($pred$)+(1-$ labels$)*$ np$.$log$(1-$ pred$))$

return np$.$mean$($Li$)$

def grad$($w$,$ data, labels$)$:

pred $=$ prediction$($w$,$ data$)$

return np$.$dot$($data$.$T$,($pred $-$ labels$))/$ len$($labels$)$

$$

def wolfe$($w$,$ p$,$ data, labels, grad$\_$f$=$grad, loss$\_$f$=$logloss$,$ pred$\_$f$=$prediction, alpha$=1\mathrm{.}0,$ c$1=0\mathrm{.}001,$ c$2=0\mathrm{.}9)$:

grad$\_$w $=$ grad$\_$f$($w$,$ data, labels$)$

for i in range$(1000)$:

if loss$\_$f$($pred$\_$f$($w $+$ alpha $*$ p$,$ data$),$ labels$)>$ loss$\_$f$($pred$\_$f$($w$,$ data$),$ labels$)+$ c$1*$ alpha $*$ np$.$dot$($grad$\_$w$,$ p$)$:

alpha $*=0\mathrm{.}5$

elif np$.$dot$($grad$\_$f$($w $+$ alpha $*$ p$,$ data, labels$),$ p$)<$ c$2*$ np$.$dot$($grad$\_$w$,$ p$)$:

alpha $*=2\mathrm{.}1$

elif i $>999$:

raise Exception$("$wolfe doesn't finish"$)$

else:

break

return alpha

def dfp$($w$\_0,$ B$\_0,$ data, labels, pred$\_$f$=$prediction, grad$\_$f$=$grad, loss$\_$f$=$logloss$,$ max$\_$iter$=100,$ tol$=0\mathrm{.}0001)$:

w $=$ w$\_0$

B$\_$inv $=$ np$.$linalg.inv$($B$\_0)$

grad$\_$w $=$ grad$\_$f$($w$,$ data, labels$)$

losses $=[]$

for i in range$($max$\_$iter$)$:

p $=-$np$.$dot$($B$\_$inv, grad$\_$w$)$

alpha $=$ wolfe$($w$,$ p$,$ data, labels, grad$\_$f$=$grad$\_$f$,$ loss$\_$f$=$loss$\_$f$)$

s $=$ alpha $*$ p

w$\_$new $=$ w $+$ s

grad$\_$new $=$ grad$\_$f$($w$\_$new, data, labels$)$

if np$.$linalg.norm$($grad$\_$new $-$ grad$\_$w$)<$ tol:

break

y $=$ grad$\_$new $-$ grad$\_$w

grad$\_$w $=$ grad$\_$new

sy $=$ np$.$dot$($s$,$ y$)$

Bs $=$ np$.$dot$($B$\_$inv, s$)$

B$\_$inv $+=$ np$.$outer$($s$,$ s$)/$ np$.$dot$($s$,$ y$)-$ np$.$outer$($Bs$,$ Bs$)/$ np$.$dot$($s$,$ Bs$)$

$$

predictions $=$ pred$\_$f$($w$,$ data$)$

loss $=$ loss$\_$f$($predictions$,$ labels$)$

print$($f$"$Iter: $\{$i$\},$ Loss: $\{$loss$\}")$

losses.append$($loss$)$

w $=$ w$\_$new

return w$,$ losses

n$=123$

B$=$np$.$eye$($n$)$ #use either identity or compute Hessian in first step for BFGS

w$=$np$.$zeros$($n$)$ #initialize weight vector

$$

features, labels $=$ read$\_$parse$\_$data$()$

n $=$ features.shape$[1]$

w$\_0=$ np$.$ones$($n$)$

B$\_0=$ np$.$eye$($n$)$

w$\_$opt, losses $=$ dfp$($w$\_0,$ B$\_0,$ features, labels, grad$\_$f$=$grad, loss$\_$f$=$logloss$)$

Iter: $0,$ Loss: $1\mathrm{.}4180136783927826$

Iter: $1,$ Loss: $1\mathrm{.}0493899267197955$

Iter: $2,$ Loss: $0\mathrm{.}3792809465978115$

Iter: $3,$ Loss: $0\mathrm{.}3714018048303409$

Iter: $4,$ Loss: $0\mathrm{.}36672889216134275$

Iter: $5,$ Loss: $0\mathrm{.}365689704361027$

Iter: $6,$ Loss: $0\mathrm{.}36430271286220156$

Iter: $7,$ Loss: $0\mathrm{.}363284481254417$

Iter: $8,$ Loss: $0\mathrm{.}3619351491046495$

Iter: $9,$ Loss: $0\mathrm{.}36079584853744845$

Iter: $10,$ Loss: $0\mathrm{.}3593349751368699$

Iter: $11,$ Loss: $0\mathrm{.}35796607021715604$