如何从列表中提取1D数组

Question

我有一个名为weightDeltas的函数，它输出一个包含2个1D数组的列表。我稍后将在另一个函数update中使用这些值。两者都会被其他1D阵列相乘。我得到一个错误，上面写着“TypeError：列表索引必须是整数或切片，而不是元组”。如何从列表中取出1D数组，以便将一个1D数组乘以另一个1D数组

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)

编辑： 我试过换衣服 wji[uu][vv]=wji[uu][vv]+np.dot（eta*delta[0][None，：]，输入[：，None]）到

wji[uu][vv]=wji[uu][vv]+np.matmul（eta*np.array（delta[0]）[None，：]，np.array（inputs）[：，None]）

抛出：ValueError:matmul:Input操作数1的核心维度0不匹配，带有gufunc签名（n？，k），（k，m？）->；（n？，m？）（8号与4号不同）

我也试过了 wji[uu][vv]=wji[uu][vv]+np.dot（eta*np.reformate（delta[0]，（4,1）），np.reformate（inputs，（1,8）））

抛出：ValueError：使用序列设置数组元素

Answer 1

我弄明白了。除其他外，我将一些功能组合在一起。我现在可以为那些熟悉神经网络的人进行模式和批/历元更新。这里缺少很多制作xVect的代码。这会使这篇文章太长。谢谢你的帮助

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])