如何从列表中提取一维数组

Question

I have a function called, weightDeltas, that outputs a list containing 2 1D arrays. I am later using those values in another function, update. Both are getting multiplied by other 1D arrays. I am getting an error that says, "TypeError: list indices must be integers or slices, not tuple". How do I get the 1D arrays out of this list so I can multiply a 1D array times another 1D array?

import math
import random
import numpy as np

def createWeights(numInputs, numNodes):
    layerWeights = np.empty([numNodes, numInputs])
    Bounds = 1/math.sqrt(numInputs)

    for q in range(numNodes):
        for r in range(numInputs):
            layerWeights[q][r] = random.uniform(- Bounds, Bounds)
    return layerWeights


def summedInput(weights, inputs, numberNodes):
    sumIn = np.empty(numberNodes)
    weightedInputs = np.multiply(weights, inputs)

    for s in range(numberNodes):
        sumIn[s] = np.sum(weightedInputs[s][:])
    return sumIn


def fNet(addedInputs):
    lam = 1
    fnet = np.empty(len(addedInputs))

    for t in range(len(addedInputs)):
        fnet[t] = 1/(1 + math.exp(-lam*addedInputs[t]))
    return fnet


def weightDeltas(tk, zk, wkj, netj, netk):
    lam = 1
    fNetj = np.empty(len(netj))
    fnetPrimej = np.empty(len(netj))
    fNetk = np.empty(len(netk))
    fnetPrimek = np.empty(len(netk))

    for u in range(len(netj)):
        fNetj[u] = 1/(1 + math.exp(-lam*netj[u]))
        fnetPrimej[u] = fNetj[u]*(1-fNetj[u])

    for v in range(len(netk)):
        fNetk[v] = 1/(1 + math.exp(-lam*netk[v]))
        fnetPrimek[v] = fNetk[v]*(1-fNetk[v])

    dk = np.transpose((tk-zk))*fnetPrimek
    dj = fnetPrimej*np.sum(np.dot(dk,wkj))
    deltas = [dj,dk]
    return deltas


def update(inputs, y, wji, wkj, deltas):
    eta = .1
    wjiDim = wji.shape
    wkjDim = wkj.shape

    for uu in range(wjiDim[0]):
        for vv in range(wjiDim[1]):
            #wji[uu][vv] = wji[uu][vv] + eta*deltas[0]*inputs
            wji[uu][vv] = wji[uu][vv] + np.dot(eta*deltas[0][None,:],inputs[:,None])

    for w in range(wkjDim[0]):
        for x in range(wkjDim[1]):
            wkj[w][x] = wkj[w][x] + eta*deltas[1]*y


testInputs = [1,2,3,4,5,6,7,8]
testTK = [1,0,0,0,0,0,0,0,0,0]            
testWeights1 = createWeights(8,4)
testSumin1 = summedInput(testWeights1, testInputs, 4)
testFnet1 = fNet(testSumin1)
testWeights2 = createWeights(4,10)
testSumin2 = summedInput(testWeights2, [testFnet1], 10)
testFnet2 = fNet(testSumin2)
testWD = weightDeltas(testTK, testFnet2, testWeights2, testSumin1, testSumin2)
up = update(testInputs, testFnet1, testWeights1, testWeights2, testWD)

EDIT: I have tried changing wji[uu][vv] = wji[uu][vv] + np.dot(eta*deltas[0][None,:],inputs[:,None]) to

wji[uu][vv] = wji[uu][vv] + np.matmul(eta*np.array(deltas[0])[None,:],np.array(inputs)[:,None]).

That throws: ValueError: matmul: Input operand 1 has a mismatch in its core dimension 0, with gufunc signature (n?,k),(k,m?)->(n?,m?) (size 8 is different from 4).

I also tried wji[uu][vv] = wji[uu][vv] + np.dot(eta*np.reshape(deltas[0],(4,1)),np.reshape(inputs, (1,8))).

That throws: ValueError: setting an array element with a sequence.

Answer 1

I got it figured out. I combined some functions together, among other things. I can now do pattern and batch/epoch updates for those who are familiar with neural networks. A lot of the code to make xVect is missing here. It would make this post far too long. Thanks for all your help!!!

import math
import random
import nump as np

def tkClassifier(randInorder):                                                                       # This function is my classifier. It returns the letters associated with
    tkOut = [0,0,0,0,0,0,0,0,0,0]

    if randInorder <= 10:
        tkOut = [1,0,0,0,0,0,0,0,0,0]

    if 10 < randInorder <= 20:
        tkOut = [0,1,0,0,0,0,0,0,0,0]

    if 20 < randInorder <= 30:
        tkOut = [0,0,1,0,0,0,0,0,0,0]

    if 30 < randInorder <= 40:
        tkOut = [0,0,0,1,0,0,0,0,0,0]

    if 40 < randInorder <= 50:
        tkOut = [0,0,0,0,1,0,0,0,0,0]

    if 50 < randInorder <= 60:
        tkOut = [0,0,0,0,0,1,0,0,0,0]

    if 60 < randInorder <= 70:
        tkOut = [0,0,0,0,0,0,1,0,0,0]

    if 70 < randInorder <= 80:
        tkOut = [0,0,0,0,0,0,0,1,0,0]

    if 80 < randInorder <= 90:
        tkOut = [0,0,0,0,0,0,0,0,1,0]

    if 90 < randInorder <= 100:
        tkOut = [0,0,0,0,0,0,0,0,0,1]

    return tkOut


def createWeights(numInputs, numNodes):
    layerWeights = np.empty([numNodes, numInputs])
    Bounds = 1/math.sqrt(numInputs)

    for q in range(numNodes):
        for r in range(numInputs):
            layerWeights[q][r] = random.uniform(- Bounds, Bounds)
    return layerWeights


def summedInput(weights, inputs, numberNodes):
    sumIn = np.empty(numberNodes)
    weightedInputs = np.multiply(weights, inputs)

    for s in range(numberNodes):
        sumIn[s] = np.sum(weightedInputs[s][:])
    return sumIn


def fNet(addedInputs):
    lam = 1
    fnet = np.empty(len(addedInputs))

    for t in range(len(addedInputs)):
        fnet[t] = 1/(1 + math.exp(-lam*addedInputs[t]))
    return fnet


def weightDeltas(inputs, tk, zk, y, wji, wkj, netj, netk):
    lam = 1
    eta = .1

    fNetj = np.empty(len(netj))
    fnetPrimej = np.empty(len(netj))
    fNetk = np.empty(len(netk))
    fnetPrimek = np.empty(len(netk))

    for u in range(len(netj)):
        fNetj[u] = 1/(1 + math.exp(-lam*netj[u]))
        fnetPrimej[u] = fNetj[u]*(1-fNetj[u])

    for v in range(len(netk)):
        fNetk[v] = 1/(1 + math.exp(-lam*netk[v]))
        fnetPrimek[v] = fNetk[v]*(1-fNetk[v])

    dk = np.transpose((tk-zk))*fnetPrimek
    dj = fnetPrimej*np.sum(np.dot(dk,wkj))
    wjidel = np.dot(eta*np.reshape(dj,(4,1)),np.reshape(inputs, (1,8)))
    wkjdel = np.dot(eta*np.reshape(dk,(10,1)),np.reshape(y, (1,4)))
    deltas = [wjidel, wkjdel]
    return deltas

def update(wji, wkj, deltas):
    for uu in range(deltas[0].shape[0]):
       for vv in range(deltas[0].shape[1]):
            wji[uu][vv] = wji[uu][vv] + deltas[0][uu][vv]


    for w in range(deltas[1].shape[0]):
        for x in range(deltas[1].shape[1]):
            wkj[w][x] = wkj[w][x] + deltas[1][w][x]


#testInputs = [1,2,3,4,5,6,7,8]
#testTK = [1,0,0,0,0,0,0,0,0,0]            
#testWeights1 = createWeights(8,4)
#print("wji:")
#print(testWeights1)
#testSumin1 = summedInput(testWeights1, testInputs, 4)
#testFnet1 = fNet(testSumin1)
#testWeights2 = createWeights(4,10)
#print("wkj:")
#print(testWeights2)
#testSumin2 = summedInput(testWeights2, [testFnet1], 10)
#testFnet2 = fNet(testSumin2)
#deltas = weightDeltas(testInputs, testTK, testFnet2, testFnet1, testWeights1, testWeights2, testSumin1, testSumin2)
#up = update(testWeights1, testWeights2, deltas)
#print("wji:")
#print(testWeights1)
#print("wkj:")
#print(testWeights2)

inputOrder = random.sample(range(tlen),tlen)
counter = 0
i = 0
wji = createWeights(8,4)
wkj = createWeights(4,10)
print("wji:")
print(wji)
print("wkj:")
print(wkj)
wjiDel = np.zeros((8,4))
wkjDel = np.zeros((4,8))

while i < 1:
    cost = 100 
    for y in range(tlen):                                                                                           # This loop runs the Bayes Classifier for part A-D.
        tk = tkClassifier(inputOrder[y])
        xVect = [m00tn[inputOrder[y]], mu02tn[inputOrder[y]], mu11tn[inputOrder[y]], mu20tn[inputOrder[y]], 
             mu03tn[inputOrder[y]], mu12tn[inputOrder[y]], mu21tn[inputOrder[y]], mu30tn[inputOrder[y]]]

        netj = summedInput(wji, xVect, 4)
        y = fNet(netj)
        netk = summedInput(wkj, [y], 10)
        zk = fNet(netk)
        deltas = weightDeltas(xVect, tk, zk, y, wji, wkj, netj, netk)
        wjiDel = deltas[0]
        wkjDel = deltas[1]
        patternUpdate = update(wji, wkj, [wjiDel,wkjDel])

        i += 1

    #batchUpdate = update(wji, wkj, [wjiDel,wkjDel])