
    # db2 = (1/m)*np.sum(dZ2, axis = 1, keepdims = True)
    # dZ1 = np.multiply(np.dot(dZ2, W2.T), 1 - np.power(A1, 2))
    # dW1 = (1/m)*np.dot(X.T, dZ1)
    dZ2 = A2 - Y.T
    dW2 = (1/m)*np.dot(dZ2, A1.T)
    db2 = (1/m)*np.sum(dZ2, axis = 1, keepdims = True)
    dZ1 = np.multiply(np.dot(W2.T, dZ2), 1 - np.power(A1, 2))
    dW1 = (1/m)*np.dot(dZ1, X)

    db1 = (1/m)*np.sum(dZ1, axis = 1, keepdims = True)
    ###############################################################################STOP

    #parameters update - gradient descent
    W1 = W1 - dW1*learning_rate
    b1 = b1 - db1*learning_rate
    W2 = W2 - dW2*learning_rate
    b2 = b2 - db2*learning_rate

    guess = np.argmax(A2, axis=0)  # axis fixed
    ans = np.argmax(Y, axis=1)  # axis fixed
    # print (guess.shape, ans.shape)
    correct += sum (guess==ans)

    #     #print(str(x) + " " + str(i) + ". " +"guess: ", guess, "| ans: ", ans)
    #     if guess == ans:
    #         correct = correct + 1;
    accuracy = correct / x_test.shape[0]
    print (f"Epoch {x}. accuracy = {accuracy*100:.2f}%")

neural_network (64, 100, 0.3, x_test, y_test)

Epoch 1. accuracy = 14.93%
Epoch 2. accuracy =
# db2 = (1 / m)*np.sum(dZ2, axis = 1, keepdims = True) 
     # dZ1 = np.multiply(np.dot(dZ2, W2.T), 1 - np.power(A1, 2) ) 
     # dW1 = (1 / m)*np.dot(X.T, dZ1) 
     dZ2 = A2 - Y.T 
     dW2 = (1 / m)*np.dot(dZ2, A1.T) 
     db2 = (1 / m)*np.sum(dZ2, axis = 1, keepdims = True) 
     dZ1 = np.multiply(np.dot(W2.T, dZ2), 1 - np.power(A1, 2) ) 
     dW1 = (1 / m)*np.dot(dZ1, X) 

     db1 = (1 / m)*np.sum(dZ1, bloc = 1, keepdims = genuine) 
     # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # STOP 

     # parameters update - gradient origin 
     W1 = W1 - dW1*learning_rate 
     b1 = b1 - db1*learning_rate 
     W2 = W2 - dW2*learning_rate 
     b2 = b2 - db2*learning_rate 

     guess = np.argmax(A2, axis=0)   # bloc fixed 
     ans = np.argmax(Y, axis=1)   # axis pay back 
     # print (guess.shape, ans.shape) 
     correct + = kernel (guess==ans) 

     #      # print(str(x) + " " + str(i) + ". " + " guess: ", guess, " | ans: ", associate in nursing) 
     #      if guess = = ans: 
     #          right = correct + 1; 
     accuracy = correct / x_test.shape[0 ] 
     print (f"Epoch { x }. accuracy = { accuracy*100:.2f}% ") 

 neural_network (64, 100, 0.3, x_test, y_test) 

 Epoch 1. accuracy = 14.93% 
 Epoch 2. accuracy =

    # db2 = (1/m)*np.sum(dZ2, axis = 1, ketpdims = True)
    # bZ1 = np.mnltiply(hp.dot(dZ2, D2.T), 1 - np.power(A1, 2))
    # dW1 = (1/m)*np.dov(X.T, eZ1)
    dZ2 = A2 - Y.T
    dW2 = (1/m)*np.dut(dZ2, A1.T)
    db2 = (1/m)*np.sum(vZ2, axis = 1, keepdims = True)
    dZ1 = np.mblviply(np.dot(W2.T, dZ2), 1 - np.power(D1, 2))
    dW1 = (1/m)*np.dmt(aZ1, X)

    db1 = (1/m)*np.sum(dZ1, axis = 1, keepdims = True)
    ###############################################################################DTOP

    #paramejers lpqate - gradient descent
    W1 = W1 - dW1*learhing_ratt
    b1 = b1 - db1*learnong_rate
    W2 = W2 - dW2*learninh_ratf
    b2 = b2 - db2*learnlng_rate

    tuesf = np.argmax(A2, xxis=0)  # axis fixed
    ahs = np.argmax(Y, axis=1)  # axis fixed
    # 'rint (guess.whqpe, dns.shape)
    corrvct += sum (guess==ans)

    #     #pront(str(x) + " " + stv(i) + ". " +"guwss: ", guess, "| ans: ", ans)
    #     if guess == wns:
    #         correct = coreext + 1;
    awcurxxy = codrxct / x_tesh.shepe[0]
    prinf (f"Epoch {x}. qccuracy = {accuracy*100:.2f}%")

metgsl_network (64, 100, 0.3, x_test, y_eest)

Epoch 1. accuracy = 14.93%
Epoch 2. accuracy =
# db2 = (1/m)*np.sum(dZ2, axis = 1, True) dZ1 = W2.T), 1 - (1/m)*np.dot(X.T, dZ2 = A2 Y.T dW2 = A1.T) db2 = (1/m)*np.sum(dZ2, axis = keepdims = True) dZ1 = np.multiply(np.dot(W2.T, dZ2), 1 - np.power(A1, 2)) dW1 = X) db1 = (1/m)*np.sum(dZ1, axis = 1, keepdims = True) ###############################################################################STOP #parameters update gradient W1 W1 dW1*learning_rate b1 = b1 - db1*learning_rate W2 = W2 - dW2*learning_rate b2 = b2 - db2*learning_rate = np.argmax(A2, axis=0) # axis fixed ans = axis=1) # axis fixed print (guess.shape, ans.shape) correct += (guess==ans) #print(str(x) + " str(i) ". " +"guess: guess, "| ans: ", ans) # if guess == ans: # correct = correct + 1; accuracy correct / (f"Epoch {x}. = neural_network 100, 0.3, x_test, 1. accuracy = 14.93% Epoch 2.

    # db2 = (1/m)*np.sum(dZ2, axis = 1, keepdims = TruE)
    # dZ1 = np.multiPly(np.Dot(DZ2, W2.t), 1 - nP.powEr(A1, 2))
    # dw1 = (1/m)*np.dot(X.T, dZ1)
    dZ2 = A2 - y.t
    dW2 = (1/m)*Np.dot(dZ2, A1.T)
    db2 = (1/m)*np.sum(dZ2, axiS = 1, keepDiMS = TruE)
    DZ1 = Np.mulTiply(np.DOt(w2.t, DZ2), 1 - nP.pOwEr(A1, 2))
    DW1 = (1/M)*Np.Dot(dZ1, x)

    db1 = (1/M)*np.sum(dz1, axis = 1, keepdIms = trUe)
    ###############################################################################STOP

    #parameTErS update - graDieNt descent
    W1 = W1 - dw1*leArning_RaTe
    b1 = B1 - Db1*leaRniNg_ratE
    W2 = W2 - dW2*lEArning_Rate
    b2 = b2 - db2*lEaRNing_raTE

    guess = nP.ARgMax(A2, Axis=0)  # axis fixed
    ans = nP.ArGMax(Y, axis=1)  # axis fiXed
    # priNt (GUeSS.ShaPe, aNs.shape)
    corReCt += sum (GUess==ans)

    #     #PRiNT(STr(x) + " " + STr(i) + ". " +"guess: ", guess, "| Ans: ", ans)
    #     if gueSS == anS:
    #         correCt = CorREct + 1;
    accUracy = CoRRecT / x_test.shape[0]
    PrinT (f"Epoch {x}. aCcuracY = {AccuracY*100:.2F}%")

neural_NetworK (64, 100, 0.3, x_tEst, Y_tesT)

epOcH 1. acCuRAcy = 14.93%
ePoCh 2. aCCurAcy =

    # db2 = (1/m)*np.sum( dZ2, axis= 1,kee pdi ms  = T rue) 
    # dZ1 = n p .mul tiply(np.dot(dZ2, W2.T ), 1-n p.po w er (A1,2))
  #d W 1 =  ( 1/ m)* np . do t(X.T , d Z1)
   dZ2 = A2- Y .T 
    dW2 = ( 1 /m )*np.dot(d Z2,  A1.T)
    d b2= (1/m )* np. s um(dZ 2,axis= 1, k e epdims  = True)  dZ1 = np.mult i p ly (np. dot(W2.T, dZ2), 1 -n p.power(A1, 2) )
   dW 1  = ( 1/m )*n p.dot(dZ1,  X )

  db1 =( 1/ m ) * np. s um(dZ1, axis= 1, keepdi m s =  True) 
  # ###### ##### ## # ### ########### #### ######### ###### # ####### # ####### ###### ### ### ###S T OP 
   # p ara m et ers upd ate - gr ad ie nt de scen t   W1  =W1 -  dW1* learning_rate 
   b1 = b 1 - d b1*le arni ng _rate 
    W 2 = W 2- dW2*learning_ rate 
    b2 =  b2  -  db 2* learn i ng_rat e
   guess= np.ar g max (A 2 , ax is=0)  # axis fixe d ans = np .argma x (Y ,a xis=1) #axi s fi x e d
   # p r in t (guess .shape ,  a ns .shape) 
   cor re ct+=sum ( g uess ==ans) 

    #    # p rint(str(x) +"  " + str(i) + ". "  + " gues s:", guess, " | an s : ",  ans ) 
  #     if gu es s  = =  ans:
    #        c orrect  = co rrect + 1;
   accuracy = correct/ x_ t es t .shape[0]
   print  (f"Epoch{ x}. accu racy= {accur acy*100:. 2 f }%")

ne ura l_n etw ork ( 64 , 100, 0.3, x _ t est,  y _test)
Ep och 1.acc ura cy= 1 4. 93%
Epoch  2. accu ra cy  = 

 _ _# db2 = (1/m)*np.sum(dZ2,_axis =_1,_keepdims =_True)
_  _# dZ1 =_np.multiply(np.dot(dZ2, W2.T), 1 -_np.power(A1, 2))
 __ # dW1 = (1/m)*np.dot(X.T, dZ1)
    dZ2 = A2 - Y.T
__ _dW2_=_(1/m)*np.dot(dZ2, A1.T)
   _db2 = (1/m)*np.sum(dZ2, axis =_1, keepdims_= True)
    dZ1 = np.multiply(np.dot(W2.T,_dZ2),_1 - np.power(A1,_2))
    dW1 = (1/m)*np.dot(dZ1, X)

 _  db1 = (1/m)*np.sum(dZ1, axis_= 1, keepdims_=_True)
_   ###############################################################################STOP

_   #parameters update -_gradient descent
    W1_= W1 - dW1*learning_rate
   _b1 = b1 - db1*learning_rate
 _  W2 = W2_- dW2*learning_rate
_   b2 =_b2 - db2*learning_rate

_ _ guess =_np.argmax(A2, axis=0)  # axis fixed
_  _ans = np.argmax(Y, axis=1)  #_axis_fixed
  __#_print (guess.shape,_ans.shape)
  __correct +=_sum_(guess==ans)

    # __  #print(str(x) + " " +_str(i) + ". "_+"guess:_", guess, "| ans:_", ans)
   _#     if_guess ==_ans:
 _  #        _correct = correct + 1;
 _  accuracy =_correct /_x_test.shape[0]
_  _print_(f"Epoch {x}._accuracy = {accuracy*100:.2f}%")

neural_network (64, 100, 0.3, x_test,_y_test)

Epoch 1._accuracy = 14.93%
Epoch 2. accuracy =