Python to Mathematica code bug

Question

I have an assignment in Mathematica, which I've already solved using Python and it's a bit hard to convert the code. Here's what I have done so far:

def sigmoid(x): # define the sigmoid function
    return 1/(1+np.exp(-x))

def pos_list(node): # returns the neighborhood of node, A is a matrix of adjacency
    return np.nonzero(A[node])[1]  

def neg_list(node): # returns nodes that are not neighbors
    return np.where(A[node]==0)[1]

I have these in Mathematica:

sigmoid[x_] := 1 / (1 + Exp[-x])
M := AdjacencyMatrix[undirectedEdges] (* this is A from above*)
posList[n_] := M[[n]]["NonzeroPositions"]
negList[n_] := Flatten[Position[Normal[M[[n]]], x_Integer /; x = 0]]

Now there is a longer function:

def next_choice(v,t,p,q):
    positive = pos_list(v)
    li = np.array([])
    for pos in positive:
        if pos==t:
            li = np.append(li,1/p)
        elif pos in pos_list(t):
            li = np.append(li,1)
        else :
            li = np.append(li,1/q)
    prob = li/li.sum()
    return np.random.choice(positive,1,p=prob)[0]

So I am stuck here. This is what I've written:

nextChoice[v_, t_, p_, q_] := 
 Module[{li, vpositive, tpositive, len, i, prob},
  li = List[];
  vpositive = posList[v];
  tpositive = posList[t];
  len = Length[vpositive];
  For[i = 1, i <= len, i++,
   If[vpositive[[i]][[1]] == t, AppendTo[li, 1/p], 
     If[Length[AnyTrue[tpositive, # == vpositive[[i]][[1]] &] > 0], 
      AppendTo[li, 1], AppendTo[li, 1/q]]];
   ];
  prob = li/Total[li];
  Return[RandomChoice[prob -> vpositive, 1][[1]]]
  ]

This list li only has one element and I cannot figure out why it doesn't go through all the if statements. any ideas?

Edit: an example

mat = {{0, 1, 0, 0, 0}, {1, 0, 1, 0, 0}, {0, 1, 0, 1, 1}, {0, 0, 1, 0, 0} , {0, 0, 1, 0, 0}};
M = SparseArray[mat]

If we call nextChoice[1, 3, 0.5, 0.5], it should return a random node from the positive list.

Answer 1

Here's my attempt at fixing your code:

mat = {{0, 1, 0, 0, 0}, {1, 0, 1, 0, 0}, {0, 1, 0, 1, 1}, {0, 0, 1, 0, 0}, {0, 0, 1, 0, 0}};
M = SparseArray[mat]

sigmoid[x_] := 1/(1 + Exp[-x])
posList[n_] := Flatten[M[[n]]["NonzeroPositions"]]
negList[n_] := Flatten[Position[Normal[M[[n]]], 0]]

nextChoice[v_, t_, p_, q_] :=
 Module[
  {vpositive, tpositive, prob},
  vpositive = posList[v];
  tpositive = posList[t];
  prob = Table[
    Which[pos == t,
     1/p,
     MemberQ[tpositive, pos],
     1,
     True,
     1/q
     ],
    {pos, vpositive}
    ];
  RandomChoice[prob -> vpositive]
  ]

nextChoice[1, 3, 0.5, 0.5]
(* 2 *)

I won't go over all the changes (feel free to ask in the comments if something is unclear), but here are some of them:

• I changed posList to return a list of indices with the same format as negList
• I switched from the For loop to a Table
• Rather than appending one element to li per loop iteration, I simply use the list returned by Table
• I swapped the nested If to Which
• You don't need to normalize the weights given to RandomChoice
• If you don't specify 1 sample for RandomChoice, it will give you a single sample without a list by default
• I switched the broken condition to use MemberQ