Обратно нейронные сети распространения


Это первый раз, когда я пытался писать обратного распространения Энн и я хотел бы знать, что более опытные люди думают о нем. Код предназначен, чтобы отличить, если текст написан на английском, французском или голландском.

Я знаю, что мой обучающий набор не очень разнообразен, но я только что получил данные от около 30 различных текстов, каждый из которых содержит 250 слов в одном из 3-х языков, так что это не моя вина. Я также знаю, что есть более простые способы сделать это, но я хотел узнать что-то о ANNs.

Я был бы рад, если бы Вы были бы достаточно любезен, чтобы дать мне свои мысли о том, как я сделал это, и как я могу улучшить его.

import math, time, random, winsound
global Usefull
LearningRate = 0.001
InWeight = [[],[],[],[],[],[]]
#Generate random InWeights
for i in range(6):
    for j in range(21):
        InWeight[i].append(random.uniform(0,1))
#21 Input Values
InNeuron = [0,0,0,0,0,0,0,
            0,0,0,0,0,0,0,
            0,0,0,0,0,0,0]
#6 Hidden Neurons
HiddenLayer = [0, 0, 0, 0, 0, 0]
#Used to calculate Delta 
HiddenLayerNoSigmoid = [0, 0, 0, 0, 0, 0]
HiddenWeight = [[],[],[]]
#Generate random HiddenWeights
for i in range(3):
    for j in range(6):
        HiddenWeight[i].append(random.uniform(0,1))
#3 Output Neurons
OutNeuron = [0, 0, 0]
#Used to calculate Delta
OutNeuronNoSigmoid = [0, 0, 0]
#Learning Table
#Engels - Nederlands - Frans - Desired output
test = [[11, 4, 8, 1, 14, 8, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0]]
test += [[4, 0, 6, 0, 4, 6, 4, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0]]
test += [[6, 0, 6, 0, 11, 8, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0]]
test += [[23, 0, 0, 0, 13, 8, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0]]
test += [[18, 4, 4, 2, 14, 8, 2, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0]]
test += [[14, 1, 6, 0, 10, 7, 2, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0]]
test += [[19, 0, 2, 0, 18, 4, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0]]
test += [[13, 1, 1, 1, 15, 7, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0]]
test += [[19, 3, 1, 0, 14, 6, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0]]
test += [[0, 0, 0, 0, 0, 0, 0, 2, 0, 5, 6, 1, 1, 8, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0]]
test += [[0, 0, 0, 0, 0, 0, 0, 3, 0, 7, 1, 3, 3, 3, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0]]
test += [[0, 0, 0, 0, 0, 0, 0, 1, 0, 12, 7, 8, 2, 3, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0]]
test += [[0, 0, 0, 0, 0, 0, 0, 4, 0, 5, 4, 4, 2, 3, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0]]
test += [[0, 0, 0, 0, 0, 0, 0, 0, 0, 4, 0, 5, 1, 13, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0]]
test += [[0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 7, 0, 7, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0]]
test += [[0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 7, 0, 13, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0]]
test += [[0, 0, 0, 0, 0, 0, 0, 0, 0, 3, 3, 14, 1, 8, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0]]
test += [[0, 0, 0, 0, 0, 0, 0, 4, 0, 2, 4, 9, 4, 3, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0]]
test += [[0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 5, 0, 3, 0, 6, 0, 8, 0, 0, 1]]
test += [[0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 7, 2, 7, 0, 1, 0, 0, 0, 0, 1]]
test += [[0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 6, 0, 1, 0, 2, 0, 1, 0, 0, 1]]
test += [[0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 6, 0, 5, 2, 2, 0, 0, 0, 0, 1]]
test += [[0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 10, 0, 7, 0, 2, 0, 2, 0, 0, 1]]
test += [[0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 9, 0, 7, 1, 1, 2, 3, 0, 0, 1]]
test += [[0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 3, 0, 8, 0, 2, 0, 2, 0, 0, 1]]
test += [[0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 3, 0, 4, 0, 3, 1, 3, 0, 0, 1]]
test += [[0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 7, 1, 5, 1, 2, 0, 0, 0, 0, 1]]

def Sigmoid(Value):
    return math.tanh(Value)

def DSigmoid(Value):  
    return 1.0 - Value**2

def UpdateHiddenNode():
    global InNeuron, InWeight
    for i in range(6):
        e = 0
        for j in range(21):
            e += InWeight[i][j]*InNeuron[j]
        HiddenLayerNoSigmoid = e
        HiddenLayer[i] = Sigmoid(e)

def UpdateOutNeuron():
    global HiddenLayer, HiddenWeight
    for i in range(3):
        e = 0
        for j in range(3):
            e += HiddenWeight[i][j]*HiddenLayer[j]
        OutNeuron[i] = Sigmoid(e)

def UpdateDelta():
    global Delta3, Delta4, Delta5, Delta6, Delta7, Delta8
    Delta3 = Delta0*HiddenWeight[0][0]+Delta1*HiddenWeight[1][0]+Delta2*HiddenWeight[2][0]
    Delta4 = Delta0*HiddenWeight[0][1]+Delta1*HiddenWeight[1][1]+Delta2*HiddenWeight[2][1]
    Delta5 = Delta0*HiddenWeight[0][2]+Delta1*HiddenWeight[1][2]+Delta2*HiddenWeight[2][2]
    Delta6 = Delta0*HiddenWeight[0][3]+Delta1*HiddenWeight[1][3]+Delta2*HiddenWeight[2][3]
    Delta7 = Delta0*HiddenWeight[0][4]+Delta1*HiddenWeight[1][4]+Delta2*HiddenWeight[2][4]
    Delta8 = Delta0*HiddenWeight[0][5]+Delta1*HiddenWeight[1][5]+Delta2*HiddenWeight[2][5]

def UpdateInWeights():
    global Delta3, Delta4, Delta5, Delta6, Delta7, Delta8
    for i in range(21):
        InWeight[0][i] += LearningRate*Delta3*DSigmoid(HiddenLayerNoSigmoid[0])*InNeuron[i]
        InWeight[1][i] += LearningRate*Delta4*DSigmoid(HiddenLayerNoSigmoid[1])*InNeuron[i]
        InWeight[2][i] += LearningRate*Delta5*DSigmoid(HiddenLayerNoSigmoid[2])*InNeuron[i]
        InWeight[3][i] += LearningRate*Delta6*DSigmoid(HiddenLayerNoSigmoid[3])*InNeuron[i]
        InWeight[4][i] += LearningRate*Delta7*DSigmoid(HiddenLayerNoSigmoid[4])*InNeuron[i]
        InWeight[5][i] += LearningRate*Delta8*DSigmoid(HiddenLayerNoSigmoid[5])*InNeuron[i]

def UpdateHiddenWeights():
    global Delta0, Delta1, Delta2
    for i in range(3):
        HiddenWeight[0][i] += LearningRate*Delta0*DSigmoid(OutNeuronNoSigmoid[0])*HiddenLayer[i]
        HiddenWeight[1][i] += LearningRate*Delta1*DSigmoid(OutNeuronNoSigmoid[1])*HiddenLayer[i]
        HiddenWeight[2][i] += LearningRate*Delta2*DSigmoid(OutNeuronNoSigmoid[2])*HiddenLayer[i]

print("Learning...")
#Start playing Learning.wav if available, else play windows default sound
#ASYNC ensures the program keeps running while playing the sound
winsound.PlaySound("Learning.wav", winsound.SND_ASYNC)
#Start timer
StartTime = time.clock()       
Iterations = 0
#Main loop
while Iterations <= 100000:
    for i in range(len(test)):
        for j in range(21):
            InNeuron[j] = test[i][j]
        UpdateHiddenNode()
        UpdateOutNeuron()
        Delta0 = test[i][21] - OutNeuron[0]
        Delta1 = test[i][22] - OutNeuron[1]
        Delta2 = test[i][23] - OutNeuron[2]
        UpdateDelta()
        UpdateInWeights()    
        UpdateHiddenWeights()
    if Iterations % 1000 == 0:
        PercentComplete = Iterations / 1000
        print("Learning " + str(PercentComplete) + "% Complete")
    Iterations += 1
#Stop playing any sound
winsound.PlaySound(None, winsound.SND_ASYNC)
print(Delta0, Delta1, Delta2)
#Save brain to SaveFile
SaveFileName = input("Save brain as: ")
SaveFile = open(SaveFileName+".txt", "w")
SaveFile.write(str(InWeight))
SaveFile.write(str(HiddenWeight))
SaveFile.close()
ElapsedTime = (time.clock() - StartTime)
print(str(ElapsedTime) + "seconds")
#Start playing Ready.wav if available, else play default windows sound
#ASYNC ensures the program keeps running while playing the sound
winsound.PlaySound("Ready.wav", winsound.SND_ASYNC)

def Input_Frequency(Document):
    WantedWords = ["i", "you", "he", "are", "the", "and", "for",
                    "ik", "jij", "hij", "zijn", "het", "niet", "een",
                    "le", "tu", "il", "avez", "une", "alors", "dans"]
    file = open(Document, "r")
    text = file.read( )
    file.close()
    #Create dictionary 
    word_freq ={}
    #Split text in words
    text = str.lower(text)
    word_list = str.split(text)

    for word in word_list:
        word_freq[word] = word_freq.get(word, 0) + 1

    #Get keys 
    keys = word_freq.keys()

    #Get frequency of usefull words
    Usefull = []
    for word in WantedWords:
        if word in keys:
            word = word_freq[word]
            Usefull.append(word)
        else:
            Usefull.append(0)
    return Usefull

def UseIt(Input):
    for i in range(len(Input)):
        InNeuron[i] = Input[i]
    UpdateHiddenNode()
    UpdateOutNeuron()
    if OutNeuron[0] > 0.99:
        return ("Engelse tekst")
    if OutNeuron[1] > 0.99:
        return ("Nederlandse tekst")
    if OutNeuron[2] > 0.99:
        return ("Franse tekst")
#Documents to investigate
#Error handling checks if you input a number
while True:
    try:
        NumberOfDocuments = int(input("Aantal te onderzoeken documenten: "))
        break
    except ValueError:
        print("That was not a valid number.")
x = 0
while NumberOfDocuments > x:
    #Error handling checks if document exists
    while True:
        try:
            Document = str(input("Document: "))
            file = open(Document, "r")
            break
        except IOError:
            print(Document +" not found")
    print(UseIt(Input_Frequency(Document)))
    #Stop playing any sound
    if x == (NumberOfDocuments - 1):
        winsound.PlaySound(None, winsound.SND_ASYNC)
    x += 1


Комментарии
1 ответ

import math, time, random, winsound
global Usefull

Глобальное заявление за пределами функции не имеет никакого эффекта

LearningRate = 0.001

Руководство по стилю Python рекомендует глобальные константы в что написано заглавными_буквами

InWeight = [[],[],[],[],[],[]]

Руководство по стилю Python для локальных переменных, имен lower_case_with_underscores

#Generate random InWeights
for i in range(6):
for j in range(21):
InWeight[i].append(random.uniform(0,1))

Логика, как это всегда должно быть в функции. Ваш основной уровень должен быть ограничен для определения функций/классов. Также вы, возможно, захотите рассмотреть возможность использования библиотеки numpy. С его помощью вы можете делать выше, а InWeight = и NumPy.случайные.случайные(6, 21)

#21 Input Values
InNeuron = [0,0,0,0,0,0,0,
0,0,0,0,0,0,0,
0,0,0,0,0,0,0]

Вы можете использовать InNeuron = [0] * 21. Говоря об этом, чисел 21 и 6 появляться в нескольких местах. Вы должны сделать их глобальной константы, так что вы можете изменить их в одном месте.

#6 Hidden Neurons
HiddenLayer = [0, 0, 0, 0, 0, 0]
#Used to calculate Delta
HiddenLayerNoSigmoid = [0, 0, 0, 0, 0, 0]
HiddenWeight = [[],[],[]]
#Generate random HiddenWeights
for i in range(3):
for j in range(6):
HiddenWeight[i].append(random.uniform(0,1))
#3 Output Neurons
OutNeuron = [0, 0, 0]
#Used to calculate Delta
OutNeuronNoSigmoid = [0, 0, 0]

Как и прежде, не нужно вводить всю таблицу нулей.

#Learning Table
#Engels - Nederlands - Frans - Desired output
test = [[11, 4, 8, 1, 14, 8, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0]]
test += [[4, 0, 6, 0, 4, 6, 4, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0]]
test += [[6, 0, 6, 0, 11, 8, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0]]
test += [[23, 0, 0, 0, 13, 8, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0]]
test += [[18, 4, 4, 2, 14, 8, 2, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0]]
test += [[14, 1, 6, 0, 10, 7, 2, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0]]
test += [[19, 0, 2, 0, 18, 4, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0]]
test += [[13, 1, 1, 1, 15, 7, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0]]
test += [[19, 3, 1, 0, 14, 6, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0]]
test += [[0, 0, 0, 0, 0, 0, 0, 2, 0, 5, 6, 1, 1, 8, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0]]
test += [[0, 0, 0, 0, 0, 0, 0, 3, 0, 7, 1, 3, 3, 3, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0]]
test += [[0, 0, 0, 0, 0, 0, 0, 1, 0, 12, 7, 8, 2, 3, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0]]
test += [[0, 0, 0, 0, 0, 0, 0, 4, 0, 5, 4, 4, 2, 3, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0]]
test += [[0, 0, 0, 0, 0, 0, 0, 0, 0, 4, 0, 5, 1, 13, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0]]
test += [[0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 7, 0, 7, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0]]
test += [[0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 7, 0, 13, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0]]
test += [[0, 0, 0, 0, 0, 0, 0, 0, 0, 3, 3, 14, 1, 8, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0]]
test += [[0, 0, 0, 0, 0, 0, 0, 4, 0, 2, 4, 9, 4, 3, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0]]
test += [[0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 5, 0, 3, 0, 6, 0, 8, 0, 0, 1]]
test += [[0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 7, 2, 7, 0, 1, 0, 0, 0, 0, 1]]
test += [[0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 6, 0, 1, 0, 2, 0, 1, 0, 0, 1]]
test += [[0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 6, 0, 5, 2, 2, 0, 0, 0, 0, 1]]
test += [[0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 10, 0, 7, 0, 2, 0, 2, 0, 0, 1]]
test += [[0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 9, 0, 7, 1, 1, 2, 3, 0, 0, 1]]
test += [[0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 3, 0, 8, 0, 2, 0, 2, 0, 0, 1]]
test += [[0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 3, 0, 4, 0, 3, 1, 3, 0, 0, 1]]
test += [[0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 7, 1, 5, 1, 2, 0, 0, 0, 0, 1]]

Почему вы используете += много времени вместо того, чтобы просто создать список в один присест? Для этого много данных, я бы, вероятно, сохранить его во внешнем файле.

def Sigmoid(Value):
return math.tanh(Value)

def DSigmoid(Value):
return 1.0 - Value**2

Руководство по стилю Python рекомендует lowercase_with_underscores для имен функций и переменных в них.

def UpdateHiddenNode():
global InNeuron, InWeight

Избегать глобальных переменных. Такие вещи действительно должны быть в классе, где InNeuron и InWeight будут атрибутами.

    for i in range(6):
e = 0

E-это зашифрованное имя переменной, учитывая расширяя его

        for j in range(21):
e += InWeight[i][j]*InNeuron[j]
HiddenLayerNoSigmoid = e
HiddenLayer[i] = Sigmoid(e)

Вся эта функция, вероятно, будет одной строки кода, если вы используете библиотеки numpy. Он также будет работать быстрее.

def UpdateOutNeuron():
global HiddenLayer, HiddenWeight
for i in range(3):
e = 0
for j in range(3):
e += HiddenWeight[i][j]*HiddenLayer[j]
OutNeuron[i] = Sigmoid(e)

Эти последние две функции, кажется, делают в основном то же самое. Можете ли вы объединить их?

def UpdateDelta():
global Delta3, Delta4, Delta5, Delta6, Delta7, Delta8
Delta3 = Delta0*HiddenWeight[0][0]+Delta1*HiddenWeight[1][0]+Delta2*HiddenWeight[2][0]
Delta4 = Delta0*HiddenWeight[0][1]+Delta1*HiddenWeight[1][1]+Delta2*HiddenWeight[2][1]
Delta5 = Delta0*HiddenWeight[0][2]+Delta1*HiddenWeight[1][2]+Delta2*HiddenWeight[2][2]
Delta6 = Delta0*HiddenWeight[0][3]+Delta1*HiddenWeight[1][3]+Delta2*HiddenWeight[2][3]
Delta7 = Delta0*HiddenWeight[0][4]+Delta1*HiddenWeight[1][4]+Delta2*HiddenWeight[2][4]
Delta8 = Delta0*HiddenWeight[0][5]+Delta1*HiddenWeight[1][5]+Delta2*HiddenWeight[2][5]

Конечно, все, что повторяющийся код выглядит некрасиво вы.Конечно, все, что повторяющийся код выглядит некрасиво вы.Конечно, все, что повторяющийся код выглядит некрасиво вы.Конечно, все, что повторяющийся код выглядит некрасиво вы.Конечно, все, что повторяющийся код выглядит некрасиво вы.Конечно, все, что повторяющийся код выглядит некрасиво вы.Конечно, все, что повторяющийся код выглядит некрасиво вы.Конечно, все, что повторяющийся код выглядит некрасиво вы.Конечно, все, что повторяющийся код выглядит некрасиво вы.

Если вы сделаете дельту список, а не набор переменных, она должна быть легко написать цикл, чтобы справиться с этим. В общем, если вы когда-нибудь найти себя создание нескольких переменных, отличающихся только количество, вы должны иметь список или массив.

def UpdateInWeights():
global Delta3, Delta4, Delta5, Delta6, Delta7, Delta8
for i in range(21):
InWeight[0][i] += LearningRate*Delta3*DSigmoid(HiddenLayerNoSigmoid[0])*InNeuron[i]
InWeight[1][i] += LearningRate*Delta4*DSigmoid(HiddenLayerNoSigmoid[1])*InNeuron[i]
InWeight[2][i] += LearningRate*Delta5*DSigmoid(HiddenLayerNoSigmoid[2])*InNeuron[i]
InWeight[3][i] += LearningRate*Delta6*DSigmoid(HiddenLayerNoSigmoid[3])*InNeuron[i]
InWeight[4][i] += LearningRate*Delta7*DSigmoid(HiddenLayerNoSigmoid[4])*InNeuron[i]
InWeight[5][i] += LearningRate*Delta8*DSigmoid(HiddenLayerNoSigmoid[5])*InNeuron[i]

И опять же, вы не достаточно ленивый. Вы должны быть слишком ленив, чтобы повторить это много кода. Переписать это как петля.

def UpdateHiddenWeights():
global Delta0, Delta1, Delta2
for i in range(3):
HiddenWeight[0][i] += LearningRate*Delta0*DSigmoid(OutNeuronNoSigmoid[0])*HiddenLayer[i]
HiddenWeight[1][i] += LearningRate*Delta1*DSigmoid(OutNeuronNoSigmoid[1])*HiddenLayer[i]
HiddenWeight[2][i] += LearningRate*Delta2*DSigmoid(OutNeuronNoSigmoid[2])*HiddenLayer[i]

Быть ленивым. Не повторяйте себя.

print("Learning...")
#Start playing Learning.wav if available, else play windows default sound
#ASYNC ensures the program keeps running while playing the sound
winsound.PlaySound("Learning.wav", winsound.SND_ASYNC)
#Start timer
StartTime = time.clock()
Iterations = 0
#Main loop
while Iterations <= 100000:

Использовать для петли

    for i in range(len(test)):
for j in range(21):
InNeuron[j] = test[i][j]

Учитывая, что тест[I] - это список, вы могли бы просто сказать InNeuron = тест[я]

        UpdateHiddenNode()
UpdateOutNeuron()
Delta0 = test[i][21] - OutNeuron[0]
Delta1 = test[i][22] - OutNeuron[1]
Delta2 = test[i][23] - OutNeuron[2]

:(

        UpdateDelta()
UpdateInWeights()
UpdateHiddenWeights()
if Iterations % 1000 == 0:
PercentComplete = Iterations / 1000
print("Learning " + str(PercentComplete) + "% Complete")

Автоматически печатать все это преобразовать в строки. Вам не нужно здесь называть ул.

    Iterations += 1
#Stop playing any sound
winsound.PlaySound(None, winsound.SND_ASYNC)
print(Delta0, Delta1, Delta2)
#Save brain to SaveFile
SaveFileName = input("Save brain as: ")
SaveFile = open(SaveFileName+".txt", "w")
SaveFile.write(str(InWeight))
SaveFile.write(str(HiddenWeight))
SaveFile.close()
ElapsedTime = (time.clock() - StartTime)

Обычно я избегаю время записи для ввода пользователя, останавливая время до вызова выше входного.

print(str(ElapsedTime) + "seconds")
#Start playing Ready.wav if available, else play default windows sound
#ASYNC ensures the program keeps running while playing the sound
winsound.PlaySound("Ready.wav", winsound.SND_ASYNC)

def Input_Frequency(Document):
WantedWords = ["i", "you", "he", "are", "the", "and", "for",
"ik", "jij", "hij", "zijn", "het", "niet", "een",
"le", "tu", "il", "avez", "une", "alors", "dans"]

Постоянные вещи, как это должно быть на главном уровне не в функции

    file = open(Document, "r")
text = file.read( )

Почему зияющие весь в прочитать( ) похоже, вы оставили дверь открытой.

    file.close()
#Create dictionary
word_freq ={}

Поставить пробел перед {} , чтобы дать ему хороший баланс

    #Split text in words
text = str.lower(text)
word_list = str.split(text)

for word in word_list:
word_freq[word] = word_freq.get(word, 0) + 1

Есть класс, коллекции.Счетчик, который делает считая подобные вещи легче.

    #Get keys 
keys = word_freq.keys()

Никакой реальной причины для этого, просто используйте ключ в word_freq вместо ключ в ключи

    #Get frequency of usefull words
Usefull = []
for word in WantedWords:
if word in keys:
word = word_freq[word]
Usefull.append(word)
else:
Usefull.append(0)

Это было бы короче сказать полезно.присоеденить(word_freq.вам(слово, 0)) вместо того, что если

    return Usefull

def UseIt(Input):
for i in range(len(Input)):
InNeuron[i] = Input[i]
UpdateHiddenNode()
UpdateOutNeuron()
if OutNeuron[0] > 0.99:
return ("Engelse tekst")
if OutNeuron[1] > 0.99:
return ("Nederlandse tekst")
if OutNeuron[2] > 0.99:
return ("Franse tekst")
#Documents to investigate
#Error handling checks if you input a number
while True:
try:
NumberOfDocuments = int(input("Aantal te onderzoeken documenten: "))
break

Стилистически, я бы поставил в другое, а не здесь.

    except ValueError:
print("That was not a valid number.")
x = 0
while NumberOfDocuments > x:
#Error handling checks if document exists
while True:
try:
Document = str(input("Document: "))
file = open(Document, "r")
break
except IOError:
print(Document +" not found")
print(UseIt(Input_Frequency(Document)))
#Stop playing any sound
if x == (NumberOfDocuments - 1):
winsound.PlaySound(None, winsound.SND_ASYNC)

Почему здесь, а не после цикла?

    x += 1

Использовать цикл for, вы должны почти никогда не использовать цикл while

6
ответ дан 18 ноября 2011 в 03:11 Источник Поделиться