как вытащить 1D массив из списка

Question

У меня есть функция под названием weightDeltas, которая выводит список, содержащий 2 одномерных массива. Позже я использую эти значения в другой функции обновления. Оба умножаются на другие одномерные массивы. Я получаю сообщение об ошибке: «TypeError: индексы списка должны быть целыми или кусочками, а не кортежем». Как я могу вывести одномерные массивы из этого списка, чтобы я мог умножить одномерный массив на другой одномерный массив?

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 * deltas [0] [None,:], вводы [:, None]) в

wji [uu] [vv] = wji [uu] [vv] + np.matmul (eta * np.array (deltas [0]) [None,:], np.array (входные данные [:, None]).

, который выдает: ValueError: matmul: операнд ввода 1 имеет несоответствие в своем основном измерении 0, с подписью gufun c (n?, k), (k, m?) -> (n?, m?) (размер 8 отличается от 4).

Я также попробовал wji [uu] [vv] = wji [uu] [vv] + np.dot (eta * np.reshape (deltas [0], (4,1)), np.reshape (входные данные, ( 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])