评价此页
★ ★ ★ ★ ★
beginner/chatbot_tutorial

注意

转至末尾 下载完整的示例代码。

聊天机器人教程#

创建于：2018年8月14日 | 最后更新：2025年1月24日 | 最后验证：2024年11月05日

作者： Matthew Inkawhich

在本教程中，我们将探索循环序列到序列模型的有趣且有用的用例。我们将使用来自 Cornell Movie-Dialogs Corpus 的电影剧本训练一个简单的聊天机器人。

对话模型是人工智能研究的热门话题。聊天机器人在各种场景中都可以找到，包括客户服务应用程序和在线帮助台。这些机器人通常由基于检索的模型驱动，这些模型会输出预定义的响应来回答特定形式的问题。在像公司 IT 帮助台这样高度受限的领域，这些模型可能就足够了，但对于更通用的用例，它们不够健壮。教机器人在多个领域与人类进行有意义的对话，这是一个远未解决的研究问题。最近，深度学习的蓬勃发展催生了像 Google 的 Neural Conversational Model 这样强大的生成模型，这标志着朝着多领域生成式对话模型迈出了重要一步。在本教程中，我们将用 PyTorch 实现这种模型。

bot 
> hello?
Bot: hello .
> where am I?
Bot: you re in a hospital .
> who are you?
Bot: i m a lawyer .
> how are you doing?
Bot: i m fine .
> are you my friend?
Bot: no .
> you're under arrest
Bot: i m trying to help you !
> i'm just kidding
Bot: i m sorry .
> where are you from?
Bot: san francisco .
> it's time for me to leave
Bot: i know .
> goodbye
Bot: goodbye .

教程亮点

  • 处理 Cornell Movie-Dialogs Corpus 数据集的加载和预处理

  • 实现带有 Luong 注意力机制 的序列到序列模型

  • 使用小批量联合训练编码器和解码器模型

  • 实现贪婪搜索解码模块

  • 与训练好的聊天机器人交互

致谢

本教程借鉴了以下来源的代码

  1. Yuan-Kuei Wu 的 pytorch-chatbot 实现： ywk991112/pytorch-chatbot

  2. Sean Robertson 的 practical-pytorch seq2seq-translation 示例： spro/practical-pytorch

  3. FloydHub Cornell Movie Corpus 预处理代码： floydhub/textutil-preprocess-cornell-movie-corpus

准备工作#

首先，请 下载 Movie-Dialogs Corpus 压缩文件。

# and put in a ``data/`` directory under the current directory.
#
# After that, let’s import some necessities.
#

import torch
from torch.jit import script, trace
import torch.nn as nn
from torch import optim
import torch.nn.functional as F
import csv
import random
import re
import os
import unicodedata
import codecs
from io import open
import itertools
import math
import json


# If the current `accelerator <https://pytorch.ac.cn/docs/stable/torch.html#accelerators>`__ is available,
# we will use it. Otherwise, we use the CPU.
device = torch.accelerator.current_accelerator().type if torch.accelerator.is_available() else "cpu"
print(f"Using {device} device")

Using cuda device

加载与预处理数据#

下一步是重新格式化我们的数据文件，并将数据加载到我们可以使用的结构中。

Cornell Movie-Dialogs Corpus 是一个丰富的电影角色对话数据集，包含

  • 220,579 对电影角色之间的对话交流

  • 来自 617 部电影的 9,035 个角色

  • 304,713 条总发言

该数据集庞大且多样，语言的正式程度、时期、情感等存在很大差异。我们希望这种多样性使我们的模型能够应对各种形式的输入和查询。

首先，让我们看看数据文件中的一些行，以了解原始格式。

corpus_name = "movie-corpus"
corpus = os.path.join("data", corpus_name)

def printLines(file, n=10):
    with open(file, 'rb') as datafile:
        lines = datafile.readlines()
    for line in lines[:n]:
        print(line)

printLines(os.path.join(corpus, "utterances.jsonl"))

b'{"id": "L1045", "conversation_id": "L1044", "text": "They do not!", "speaker": "u0", "meta": {"movie_id": "m0", "parsed": [{"rt": 1, "toks": [{"tok": "They", "tag": "PRP", "dep": "nsubj", "up": 1, "dn": []}, {"tok": "do", "tag": "VBP", "dep": "ROOT", "dn": [0, 2, 3]}, {"tok": "not", "tag": "RB", "dep": "neg", "up": 1, "dn": []}, {"tok": "!", "tag": ".", "dep": "punct", "up": 1, "dn": []}]}]}, "reply-to": "L1044", "timestamp": null, "vectors": []}\n'
b'{"id": "L1044", "conversation_id": "L1044", "text": "They do to!", "speaker": "u2", "meta": {"movie_id": "m0", "parsed": [{"rt": 1, "toks": [{"tok": "They", "tag": "PRP", "dep": "nsubj", "up": 1, "dn": []}, {"tok": "do", "tag": "VBP", "dep": "ROOT", "dn": [0, 2, 3]}, {"tok": "to", "tag": "TO", "dep": "dobj", "up": 1, "dn": []}, {"tok": "!", "tag": ".", "dep": "punct", "up": 1, "dn": []}]}]}, "reply-to": null, "timestamp": null, "vectors": []}\n'
b'{"id": "L985", "conversation_id": "L984", "text": "I hope so.", "speaker": "u0", "meta": {"movie_id": "m0", "parsed": [{"rt": 1, "toks": [{"tok": "I", "tag": "PRP", "dep": "nsubj", "up": 1, "dn": []}, {"tok": "hope", "tag": "VBP", "dep": "ROOT", "dn": [0, 2, 3]}, {"tok": "so", "tag": "RB", "dep": "advmod", "up": 1, "dn": []}, {"tok": ".", "tag": ".", "dep": "punct", "up": 1, "dn": []}]}]}, "reply-to": "L984", "timestamp": null, "vectors": []}\n'
b'{"id": "L984", "conversation_id": "L984", "text": "She okay?", "speaker": "u2", "meta": {"movie_id": "m0", "parsed": [{"rt": 1, "toks": [{"tok": "She", "tag": "PRP", "dep": "nsubj", "up": 1, "dn": []}, {"tok": "okay", "tag": "RB", "dep": "ROOT", "dn": [0, 2]}, {"tok": "?", "tag": ".", "dep": "punct", "up": 1, "dn": []}]}]}, "reply-to": null, "timestamp": null, "vectors": []}\n'
b'{"id": "L925", "conversation_id": "L924", "text": "Let\'s go.", "speaker": "u0", "meta": {"movie_id": "m0", "parsed": [{"rt": 0, "toks": [{"tok": "Let", "tag": "VB", "dep": "ROOT", "dn": [2, 3]}, {"tok": "\'s", "tag": "PRP", "dep": "nsubj", "up": 2, "dn": []}, {"tok": "go", "tag": "VB", "dep": "ccomp", "up": 0, "dn": [1]}, {"tok": ".", "tag": ".", "dep": "punct", "up": 0, "dn": []}]}]}, "reply-to": "L924", "timestamp": null, "vectors": []}\n'
b'{"id": "L924", "conversation_id": "L924", "text": "Wow", "speaker": "u2", "meta": {"movie_id": "m0", "parsed": [{"rt": 0, "toks": [{"tok": "Wow", "tag": "UH", "dep": "ROOT", "dn": []}]}]}, "reply-to": null, "timestamp": null, "vectors": []}\n'
b'{"id": "L872", "conversation_id": "L870", "text": "Okay -- you\'re gonna need to learn how to lie.", "speaker": "u0", "meta": {"movie_id": "m0", "parsed": [{"rt": 4, "toks": [{"tok": "Okay", "tag": "UH", "dep": "intj", "up": 4, "dn": []}, {"tok": "--", "tag": ":", "dep": "punct", "up": 4, "dn": []}, {"tok": "you", "tag": "PRP", "dep": "nsubj", "up": 4, "dn": []}, {"tok": "\'re", "tag": "VBP", "dep": "aux", "up": 4, "dn": []}, {"tok": "gon", "tag": "VBG", "dep": "ROOT", "dn": [0, 1, 2, 3, 6, 12]}, {"tok": "na", "tag": "TO", "dep": "aux", "up": 6, "dn": []}, {"tok": "need", "tag": "VB", "dep": "xcomp", "up": 4, "dn": [5, 8]}, {"tok": "to", "tag": "TO", "dep": "aux", "up": 8, "dn": []}, {"tok": "learn", "tag": "VB", "dep": "xcomp", "up": 6, "dn": [7, 11]}, {"tok": "how", "tag": "WRB", "dep": "advmod", "up": 11, "dn": []}, {"tok": "to", "tag": "TO", "dep": "aux", "up": 11, "dn": []}, {"tok": "lie", "tag": "VB", "dep": "xcomp", "up": 8, "dn": [9, 10]}, {"tok": ".", "tag": ".", "dep": "punct", "up": 4, "dn": []}]}]}, "reply-to": "L871", "timestamp": null, "vectors": []}\n'
b'{"id": "L871", "conversation_id": "L870", "text": "No", "speaker": "u2", "meta": {"movie_id": "m0", "parsed": [{"rt": 0, "toks": [{"tok": "No", "tag": "UH", "dep": "ROOT", "dn": []}]}]}, "reply-to": "L870", "timestamp": null, "vectors": []}\n'
b'{"id": "L870", "conversation_id": "L870", "text": "I\'m kidding.  You know how sometimes you just become this \\"persona\\"?  And you don\'t know how to quit?", "speaker": "u0", "meta": {"movie_id": "m0", "parsed": [{"rt": 2, "toks": [{"tok": "I", "tag": "PRP", "dep": "nsubj", "up": 2, "dn": []}, {"tok": "\'m", "tag": "VBP", "dep": "aux", "up": 2, "dn": []}, {"tok": "kidding", "tag": "VBG", "dep": "ROOT", "dn": [0, 1, 3]}, {"tok": ".", "tag": ".", "dep": "punct", "up": 2, "dn": [4]}, {"tok": " ", "tag": "_SP", "dep": "", "up": 3, "dn": []}]}, {"rt": 1, "toks": [{"tok": "You", "tag": "PRP", "dep": "nsubj", "up": 1, "dn": []}, {"tok": "know", "tag": "VBP", "dep": "ROOT", "dn": [0, 6, 11]}, {"tok": "how", "tag": "WRB", "dep": "advmod", "up": 3, "dn": []}, {"tok": "sometimes", "tag": "RB", "dep": "advmod", "up": 6, "dn": [2]}, {"tok": "you", "tag": "PRP", "dep": "nsubj", "up": 6, "dn": []}, {"tok": "just", "tag": "RB", "dep": "advmod", "up": 6, "dn": []}, {"tok": "become", "tag": "VBP", "dep": "ccomp", "up": 1, "dn": [3, 4, 5, 9]}, {"tok": "this", "tag": "DT", "dep": "det", "up": 9, "dn": []}, {"tok": "\\"", "tag": "``", "dep": "punct", "up": 9, "dn": []}, {"tok": "persona", "tag": "NN", "dep": "attr", "up": 6, "dn": [7, 8, 10]}, {"tok": "\\"", "tag": "\'\'", "dep": "punct", "up": 9, "dn": []}, {"tok": "?", "tag": ".", "dep": "punct", "up": 1, "dn": [12]}, {"tok": " ", "tag": "_SP", "dep": "", "up": 11, "dn": []}]}, {"rt": 4, "toks": [{"tok": "And", "tag": "CC", "dep": "cc", "up": 4, "dn": []}, {"tok": "you", "tag": "PRP", "dep": "nsubj", "up": 4, "dn": []}, {"tok": "do", "tag": "VBP", "dep": "aux", "up": 4, "dn": []}, {"tok": "n\'t", "tag": "RB", "dep": "neg", "up": 4, "dn": []}, {"tok": "know", "tag": "VB", "dep": "ROOT", "dn": [0, 1, 2, 3, 7, 8]}, {"tok": "how", "tag": "WRB", "dep": "advmod", "up": 7, "dn": []}, {"tok": "to", "tag": "TO", "dep": "aux", "up": 7, "dn": []}, {"tok": "quit", "tag": "VB", "dep": "xcomp", "up": 4, "dn": [5, 6]}, {"tok": "?", "tag": ".", "dep": "punct", "up": 4, "dn": []}]}]}, "reply-to": null, "timestamp": null, "vectors": []}\n'
b'{"id": "L869", "conversation_id": "L866", "text": "Like my fear of wearing pastels?", "speaker": "u0", "meta": {"movie_id": "m0", "parsed": [{"rt": 0, "toks": [{"tok": "Like", "tag": "IN", "dep": "ROOT", "dn": [2, 6]}, {"tok": "my", "tag": "PRP$", "dep": "poss", "up": 2, "dn": []}, {"tok": "fear", "tag": "NN", "dep": "pobj", "up": 0, "dn": [1, 3]}, {"tok": "of", "tag": "IN", "dep": "prep", "up": 2, "dn": [4]}, {"tok": "wearing", "tag": "VBG", "dep": "pcomp", "up": 3, "dn": [5]}, {"tok": "pastels", "tag": "NNS", "dep": "dobj", "up": 4, "dn": []}, {"tok": "?", "tag": ".", "dep": "punct", "up": 0, "dn": []}]}]}, "reply-to": "L868", "timestamp": null, "vectors": []}\n'

创建格式化的数据文件#

为了方便起见，我们将创建一个格式良好的数据文件，其中每行包含一个制表符分隔的查询句子和响应句子对。

以下函数有助于解析原始的 utterances.jsonl 数据文件。

  • loadLinesAndConversations 将文件中的每一行拆分为一个行字典，其中包含：lineID、characterID 和文本，然后将它们分组为对话，其中包含：conversationID、movieID 和行。

  • extractSentencePairs 从对话中提取句子对。

# Splits each line of the file to create lines and conversations
def loadLinesAndConversations(fileName):
    lines = {}
    conversations = {}
    with open(fileName, 'r', encoding='iso-8859-1') as f:
        for line in f:
            lineJson = json.loads(line)
            # Extract fields for line object
            lineObj = {}
            lineObj["lineID"] = lineJson["id"]
            lineObj["characterID"] = lineJson["speaker"]
            lineObj["text"] = lineJson["text"]
            lines[lineObj['lineID']] = lineObj

            # Extract fields for conversation object
            if lineJson["conversation_id"] not in conversations:
                convObj = {}
                convObj["conversationID"] = lineJson["conversation_id"]
                convObj["movieID"] = lineJson["meta"]["movie_id"]
                convObj["lines"] = [lineObj]
            else:
                convObj = conversations[lineJson["conversation_id"]]
                convObj["lines"].insert(0, lineObj)
            conversations[convObj["conversationID"]] = convObj

    return lines, conversations


# Extracts pairs of sentences from conversations
def extractSentencePairs(conversations):
    qa_pairs = []
    for conversation in conversations.values():
        # Iterate over all the lines of the conversation
        for i in range(len(conversation["lines"]) - 1):  # We ignore the last line (no answer for it)
            inputLine = conversation["lines"][i]["text"].strip()
            targetLine = conversation["lines"][i+1]["text"].strip()
            # Filter wrong samples (if one of the lists is empty)
            if inputLine and targetLine:
                qa_pairs.append([inputLine, targetLine])
    return qa_pairs

现在我们将调用这些函数并创建文件。我们将其命名为 formatted_movie_lines.txt。

# Define path to new file
datafile = os.path.join(corpus, "formatted_movie_lines.txt")

delimiter = '\t'
# Unescape the delimiter
delimiter = str(codecs.decode(delimiter, "unicode_escape"))

# Initialize lines dict and conversations dict
lines = {}
conversations = {}
# Load lines and conversations
print("\nProcessing corpus into lines and conversations...")
lines, conversations = loadLinesAndConversations(os.path.join(corpus, "utterances.jsonl"))

# Write new csv file
print("\nWriting newly formatted file...")
with open(datafile, 'w', encoding='utf-8') as outputfile:
    writer = csv.writer(outputfile, delimiter=delimiter, lineterminator='\n')
    for pair in extractSentencePairs(conversations):
        writer.writerow(pair)

# Print a sample of lines
print("\nSample lines from file:")
printLines(datafile)

Processing corpus into lines and conversations...

Writing newly formatted file...

Sample lines from file:
b'They do to!\tThey do not!\n'
b'She okay?\tI hope so.\n'
b"Wow\tLet's go.\n"
b'"I\'m kidding.  You know how sometimes you just become this ""persona""?  And you don\'t know how to quit?"\tNo\n'
b"No\tOkay -- you're gonna need to learn how to lie.\n"
b"I figured you'd get to the good stuff eventually.\tWhat good stuff?\n"
b'What good stuff?\t"The ""real you""."\n'
b'"The ""real you""."\tLike my fear of wearing pastels?\n'
b'do you listen to this crap?\tWhat crap?\n'
b"What crap?\tMe.  This endless ...blonde babble. I'm like, boring myself.\n"

加载和修剪数据#

我们的下一步是构建词汇表并将查询/响应句子对加载到内存中。

请注意，我们处理的是**单词**序列，这些单词没有隐式映射到离散的数值空间。因此，我们必须通过将数据集中遇到的每个唯一单词映射到一个索引值来创建一个映射。

为此，我们定义了一个 Voc 类，它维护一个从单词到索引的映射，一个从索引到单词的反向映射，每个单词的计数以及总单词数。该类提供了向词汇表添加单词（addWord）、添加句子中的所有单词（addSentence）以及修剪不常出现的单词（trim）的方法。稍后将详细介绍修剪。

# Default word tokens
PAD_token = 0  # Used for padding short sentences
SOS_token = 1  # Start-of-sentence token
EOS_token = 2  # End-of-sentence token

class Voc:
    def __init__(self, name):
        self.name = name
        self.trimmed = False
        self.word2index = {}
        self.word2count = {}
        self.index2word = {PAD_token: "PAD", SOS_token: "SOS", EOS_token: "EOS"}
        self.num_words = 3  # Count SOS, EOS, PAD

    def addSentence(self, sentence):
        for word in sentence.split(' '):
            self.addWord(word)

    def addWord(self, word):
        if word not in self.word2index:
            self.word2index[word] = self.num_words
            self.word2count[word] = 1
            self.index2word[self.num_words] = word
            self.num_words += 1
        else:
            self.word2count[word] += 1

    # Remove words below a certain count threshold
    def trim(self, min_count):
        if self.trimmed:
            return
        self.trimmed = True

        keep_words = []

        for k, v in self.word2count.items():
            if v >= min_count:
                keep_words.append(k)

        print('keep_words {} / {} = {:.4f}'.format(
            len(keep_words), len(self.word2index), len(keep_words) / len(self.word2index)
        ))

        # Reinitialize dictionaries
        self.word2index = {}
        self.word2count = {}
        self.index2word = {PAD_token: "PAD", SOS_token: "SOS", EOS_token: "EOS"}
        self.num_words = 3 # Count default tokens

        for word in keep_words:
            self.addWord(word)

现在我们可以组装我们的词汇表和查询/响应句子对。在我们准备好使用这些数据之前，必须执行一些预处理。

首先，我们必须使用 unicodeToAscii 将 Unicode 字符串转换为 ASCII。接下来，我们应该将所有字母转换为小写，并删除所有非字母字符，除了基本的标点符号（normalizeString）。最后，为了帮助模型收敛，我们将过滤掉长度超过 MAX_LENGTH 阈值的句子（filterPairs）。

MAX_LENGTH = 10  # Maximum sentence length to consider

# Turn a Unicode string to plain ASCII, thanks to
# https://stackoverflow.com/a/518232/2809427
def unicodeToAscii(s):
    return ''.join(
        c for c in unicodedata.normalize('NFD', s)
        if unicodedata.category(c) != 'Mn'
    )

# Lowercase, trim, and remove non-letter characters
def normalizeString(s):
    s = unicodeToAscii(s.lower().strip())
    s = re.sub(r"([.!?])", r" \1", s)
    s = re.sub(r"[^a-zA-Z.!?]+", r" ", s)
    s = re.sub(r"\s+", r" ", s).strip()
    return s

# Read query/response pairs and return a voc object
def readVocs(datafile, corpus_name):
    print("Reading lines...")
    # Read the file and split into lines
    lines = open(datafile, encoding='utf-8').\
        read().strip().split('\n')
    # Split every line into pairs and normalize
    pairs = [[normalizeString(s) for s in l.split('\t')] for l in lines]
    voc = Voc(corpus_name)
    return voc, pairs

# Returns True if both sentences in a pair 'p' are under the MAX_LENGTH threshold
def filterPair(p):
    # Input sequences need to preserve the last word for EOS token
    return len(p[0].split(' ')) < MAX_LENGTH and len(p[1].split(' ')) < MAX_LENGTH

# Filter pairs using the ``filterPair`` condition
def filterPairs(pairs):
    return [pair for pair in pairs if filterPair(pair)]

# Using the functions defined above, return a populated voc object and pairs list
def loadPrepareData(corpus, corpus_name, datafile, save_dir):
    print("Start preparing training data ...")
    voc, pairs = readVocs(datafile, corpus_name)
    print("Read {!s} sentence pairs".format(len(pairs)))
    pairs = filterPairs(pairs)
    print("Trimmed to {!s} sentence pairs".format(len(pairs)))
    print("Counting words...")
    for pair in pairs:
        voc.addSentence(pair[0])
        voc.addSentence(pair[1])
    print("Counted words:", voc.num_words)
    return voc, pairs


# Load/Assemble voc and pairs
save_dir = os.path.join("data", "save")
voc, pairs = loadPrepareData(corpus, corpus_name, datafile, save_dir)
# Print some pairs to validate
print("\npairs:")
for pair in pairs[:10]:
    print(pair)

Start preparing training data ...
Reading lines...
Read 221282 sentence pairs
Trimmed to 64313 sentence pairs
Counting words...
Counted words: 18082

pairs:
['they do to !', 'they do not !']
['she okay ?', 'i hope so .']
['wow', 'let s go .']
['what good stuff ?', 'the real you .']
['the real you .', 'like my fear of wearing pastels ?']
['do you listen to this crap ?', 'what crap ?']
['well no . . .', 'then that s all you had to say .']
['then that s all you had to say .', 'but']
['but', 'you always been this selfish ?']
['have fun tonight ?', 'tons']

另一个有助于实现更快收敛的技巧是修剪掉我们词汇表中很少使用的单词。减小特征空间也将软化模型必须学习逼近的函数的难度。我们将分两步完成此操作：

  1. 使用 voc.trim 函数修剪使用次数低于 MIN_COUNT 阈值的单词。

  2. 过滤掉包含修剪后单词的对。

MIN_COUNT = 3    # Minimum word count threshold for trimming

def trimRareWords(voc, pairs, MIN_COUNT):
    # Trim words used under the MIN_COUNT from the voc
    voc.trim(MIN_COUNT)
    # Filter out pairs with trimmed words
    keep_pairs = []
    for pair in pairs:
        input_sentence = pair[0]
        output_sentence = pair[1]
        keep_input = True
        keep_output = True
        # Check input sentence
        for word in input_sentence.split(' '):
            if word not in voc.word2index:
                keep_input = False
                break
        # Check output sentence
        for word in output_sentence.split(' '):
            if word not in voc.word2index:
                keep_output = False
                break

        # Only keep pairs that do not contain trimmed word(s) in their input or output sentence
        if keep_input and keep_output:
            keep_pairs.append(pair)

    print("Trimmed from {} pairs to {}, {:.4f} of total".format(len(pairs), len(keep_pairs), len(keep_pairs) / len(pairs)))
    return keep_pairs


# Trim voc and pairs
pairs = trimRareWords(voc, pairs, MIN_COUNT)

keep_words 7833 / 18079 = 0.4333
Trimmed from 64313 pairs to 53131, 0.8261 of total

为模型准备数据#

尽管我们在准备和整理数据以构建一个良好的词汇表对象和句子对列表方面付出了很多努力，但我们的模型最终期望输入是数值型的 torch tensor。准备好处理数据的一种方法可以在 seq2seq 翻译教程 中找到。在该教程中，我们使用的批量大小为 1，这意味着我们只需将句子对中的单词转换为它们在词汇表中的相应索引，然后将其馈送到模型。

但是，如果您想加快训练速度和/或想利用 GPU 并行化功能，您将需要使用小批量进行训练。

使用小批量训练也意味着我们必须注意批量中句子长度的变化。为了适应同一批次中不同大小的句子，我们将把输入的批量张量形状设置为(max_length, batch_size)，其中比max_length短的句子在EOS_token之后用零填充。

如果我们仅通过将单词转换为索引（indexesFromSentence）并进行零填充来将英语句子转换为张量，则我们的张量将具有形状(batch_size, max_length)，并且索引第一个维度将返回跨所有时间步的完整序列。然而，我们需要能够按时间步索引我们的批次，并跨批次中的所有序列进行索引。因此，我们将输入批次的形状转置为(max_length, batch_size)，以便按第一个维度索引时，可以获得批次中所有句子的时间步。我们在 zeroPadding 函数中隐式处理了这一点。

batches

inputVar 函数处理将句子转换为张量的过程，最终创建一个形状正确的零填充张量。它还返回一个包含批次中每个序列长度的 lengths 张量，该张量稍后将传递给我们的解码器。

outputVar 函数执行与 inputVar 类似的功能，但它返回的不是 lengths 张量，而是返回一个二值掩码张量和一个最大目标句子长度。二值掩码张量的形状与输出目标张量相同，但所有对应于PAD_token的元素为 0，所有其他元素为 1。

batch2TrainData 简单地接收一批对，并使用上述函数返回输入和目标张量。

def indexesFromSentence(voc, sentence):
    return [voc.word2index[word] for word in sentence.split(' ')] + [EOS_token]


def zeroPadding(l, fillvalue=PAD_token):
    return list(itertools.zip_longest(*l, fillvalue=fillvalue))

def binaryMatrix(l, value=PAD_token):
    m = []
    for i, seq in enumerate(l):
        m.append([])
        for token in seq:
            if token == PAD_token:
                m[i].append(0)
            else:
                m[i].append(1)
    return m

# Returns padded input sequence tensor and lengths
def inputVar(l, voc):
    indexes_batch = [indexesFromSentence(voc, sentence) for sentence in l]
    lengths = torch.tensor([len(indexes) for indexes in indexes_batch])
    padList = zeroPadding(indexes_batch)
    padVar = torch.LongTensor(padList)
    return padVar, lengths

# Returns padded target sequence tensor, padding mask, and max target length
def outputVar(l, voc):
    indexes_batch = [indexesFromSentence(voc, sentence) for sentence in l]
    max_target_len = max([len(indexes) for indexes in indexes_batch])
    padList = zeroPadding(indexes_batch)
    mask = binaryMatrix(padList)
    mask = torch.BoolTensor(mask)
    padVar = torch.LongTensor(padList)
    return padVar, mask, max_target_len

# Returns all items for a given batch of pairs
def batch2TrainData(voc, pair_batch):
    pair_batch.sort(key=lambda x: len(x[0].split(" ")), reverse=True)
    input_batch, output_batch = [], []
    for pair in pair_batch:
        input_batch.append(pair[0])
        output_batch.append(pair[1])
    inp, lengths = inputVar(input_batch, voc)
    output, mask, max_target_len = outputVar(output_batch, voc)
    return inp, lengths, output, mask, max_target_len


# Example for validation
small_batch_size = 5
batches = batch2TrainData(voc, [random.choice(pairs) for _ in range(small_batch_size)])
input_variable, lengths, target_variable, mask, max_target_len = batches

print("input_variable:", input_variable)
print("lengths:", lengths)
print("target_variable:", target_variable)
print("mask:", mask)
print("max_target_len:", max_target_len)

input_variable: tensor([[ 287,   26,   26,   36, 1040],
        [ 288, 1012,  411,   17,   14],
        [ 167,  235,  606,  358, 5455],
        [  14, 1012,   14,   14,    6],
        [1361,   14,    2,    2,    2],
        [  92,    2,    0,    0,    0],
        [  14,    0,    0,    0,    0],
        [   2,    0,    0,    0,    0]])
lengths: tensor([8, 6, 5, 5, 5])
target_variable: tensor([[ 186,   11,   79, 6229, 6884],
        [ 124,   44,  411,   19,    6],
        [ 172,  228, 2716,  362,    2],
        [ 141,   28,  105,    5,    0],
        [  14,  929, 2717,   22,    0],
        [   2,   14,   14, 1001,    0],
        [   0,    2,    2,   10,    0],
        [   0,    0,    0,    2,    0]])
mask: tensor([[ True,  True,  True,  True,  True],
        [ True,  True,  True,  True,  True],
        [ True,  True,  True,  True,  True],
        [ True,  True,  True,  True, False],
        [ True,  True,  True,  True, False],
        [ True,  True,  True,  True, False],
        [False,  True,  True,  True, False],
        [False, False, False,  True, False]])
max_target_len: 8

定义模型#

Seq2Seq 模型#

我们聊天机器人的核心是序列到序列（seq2seq）模型。seq2seq 模型的目标是接收一个可变长度的序列作为输入，并使用固定大小的模型返回一个可变长度的序列作为输出。

Sutskever 等人 发现，通过将两个独立的循环神经网络结合使用，我们可以完成这项任务。一个 RNN 充当**编码器**，它将可变长度的输入序列编码为固定长度的上下文向量。理论上，这个上下文向量（RNN 的最后一个隐藏层）将包含输入到机器人的查询句子的语义信息。第二个 RNN 是一个**解码器**，它接收一个输入单词和上下文向量，并返回对序列中下一个单词的猜测以及将在下一个迭代中使用的隐藏状态。

model

图片来源： https://jeddy92.github.io/JEddy92.github.io/ts_seq2seq_intro/

编码器#

编码器 RNN 一次处理输入句子中的一个 token（例如，单词），在每个时间步输出一个“输出”向量和一个“隐藏状态”向量。隐藏状态向量然后传递到下一个时间步，而输出向量被记录下来。编码器将序列中每个点的上下文转换为高维空间中的一组点，解码器将使用这些点来生成给定任务的有意义的输出。

我们编码器的核心是多层门控循环单元（GRU），由 Cho 等人 于 2014 年发明。我们将使用 GRU 的双向变体，这意味着实际上有两个独立的 RNN：一个以正常顺序处理输入序列，另一个以反向顺序处理输入序列。每个网络的输出在每个时间步相加。使用双向 GRU 将使我们能够同时编码过去和未来的上下文。

双向 RNN

rnn_bidir

图片来源： https://colah.github.io/posts/2015-09-NN-Types-FP/

请注意，embedding 层用于将我们的单词索引编码到任意大小的特征空间中。对于我们的模型，此层会将每个单词映射到大小为 *hidden_size* 的特征空间。训练后，这些值应编码相似含义单词之间的语义相似性。

最后，如果将填充后的序列批次传递给 RNN 模块，我们必须在 RNN 传递周围使用 nn.utils.rnn.pack_padded_sequence 和 nn.utils.rnn.pad_packed_sequence 来打包和解包填充。

计算图

  1. 将单词索引转换为嵌入。

  2. 为 RNN 模块打包填充后的序列批次。

  3. 通过 GRU 进行前向传播。

  4. 解包填充。

  5. 对双向 GRU 输出进行求和。

  6. 返回输出和最终隐藏状态。

输入

  • input_seq：输入句子批次；形状=(max_length, batch_size)

  • input_lengths：批次中对应于每个句子的句子长度列表；形状=(batch_size)

  • hidden：隐藏状态；形状=(n_layers x num_directions, batch_size, hidden_size)

输出

  • outputs：GRU 最后一个隐藏层的输出特征（双向输出之和）；形状=(max_length, batch_size, hidden_size)

  • hidden：GRU 的更新隐藏状态；形状=(n_layers x num_directions, batch_size, hidden_size)

class EncoderRNN(nn.Module):
    def __init__(self, hidden_size, embedding, n_layers=1, dropout=0):
        super(EncoderRNN, self).__init__()
        self.n_layers = n_layers
        self.hidden_size = hidden_size
        self.embedding = embedding

        # Initialize GRU; the input_size and hidden_size parameters are both set to 'hidden_size'
        #   because our input size is a word embedding with number of features == hidden_size
        self.gru = nn.GRU(hidden_size, hidden_size, n_layers,
                          dropout=(0 if n_layers == 1 else dropout), bidirectional=True)

    def forward(self, input_seq, input_lengths, hidden=None):
        # Convert word indexes to embeddings
        embedded = self.embedding(input_seq)
        # Pack padded batch of sequences for RNN module
        packed = nn.utils.rnn.pack_padded_sequence(embedded, input_lengths)
        # Forward pass through GRU
        outputs, hidden = self.gru(packed, hidden)
        # Unpack padding
        outputs, _ = nn.utils.rnn.pad_packed_sequence(outputs)
        # Sum bidirectional GRU outputs
        outputs = outputs[:, :, :self.hidden_size] + outputs[:, : ,self.hidden_size:]
        # Return output and final hidden state
        return outputs, hidden

解码器#

解码器 RNN 以逐个 token 的方式生成响应句子。它使用编码器的上下文向量和内部隐藏状态来生成序列中的下一个单词。它继续生成单词，直到输出EOS_token，表示句子结束。标准的 seq2seq 解码器的一个常见问题是，如果我们仅依赖上下文向量来编码整个输入序列的含义，很可能会丢失信息。特别是当处理长输入序列时，这会极大地限制我们解码器的能力。

为了解决这个问题，Bahdanau 等人 创建了一个“注意力机制”，该机制允许解码器关注输入序列的某些部分，而不是在每一步都使用整个固定上下文。

总的来说，注意力是通过解码器的当前隐藏状态和编码器的输出来计算的。输出的注意力权重与输入序列的形状相同，允许我们将它们乘以编码器的输岀，从而得到一个加权和，表示需要关注的编码器输出部分。 Sean Robertson 的图很好地描述了这一点。

attn2

Luong 等人 在 Bahdanau 等人的基础上进行了改进，创建了“全局注意力”。关键区别在于，对于“全局注意力”，我们考虑编码器的所有隐藏状态，而 Bahdanau 等人的“局部注意力”仅考虑当前时间步的编码器隐藏状态。另一个区别是，对于“全局注意力”，我们仅使用当前时间步解码器的隐藏状态来计算注意力权重（或能量）。Bahdanau 等人的注意力计算需要了解前一个时间步解码器的状态。此外，Luong 等人提供了多种计算编码器输出和解码器输出之间注意力能量的方法，这些方法称为“得分函数”。

scores

其中 \(h_t\) = 当前目标解码器状态，\(\bar{h}_s\) = 所有编码器状态。

总的来说，全局注意力机制可以通过下图来概括。请注意，我们将“注意力层”实现为一个单独的 nn.Module，名为 Attn。此模块的输出是一个形状为(batch_size, 1, max_length)的 softmax 归一化权重张量。

global_attn 
# Luong attention layer
class Attn(nn.Module):
    def __init__(self, method, hidden_size):
        super(Attn, self).__init__()
        self.method = method
        if self.method not in ['dot', 'general', 'concat']:
            raise ValueError(self.method, "is not an appropriate attention method.")
        self.hidden_size = hidden_size
        if self.method == 'general':
            self.attn = nn.Linear(self.hidden_size, hidden_size)
        elif self.method == 'concat':
            self.attn = nn.Linear(self.hidden_size * 2, hidden_size)
            self.v = nn.Parameter(torch.FloatTensor(hidden_size))

    def dot_score(self, hidden, encoder_output):
        return torch.sum(hidden * encoder_output, dim=2)

    def general_score(self, hidden, encoder_output):
        energy = self.attn(encoder_output)
        return torch.sum(hidden * energy, dim=2)

    def concat_score(self, hidden, encoder_output):
        energy = self.attn(torch.cat((hidden.expand(encoder_output.size(0), -1, -1), encoder_output), 2)).tanh()
        return torch.sum(self.v * energy, dim=2)

    def forward(self, hidden, encoder_outputs):
        # Calculate the attention weights (energies) based on the given method
        if self.method == 'general':
            attn_energies = self.general_score(hidden, encoder_outputs)
        elif self.method == 'concat':
            attn_energies = self.concat_score(hidden, encoder_outputs)
        elif self.method == 'dot':
            attn_energies = self.dot_score(hidden, encoder_outputs)

        # Transpose max_length and batch_size dimensions
        attn_energies = attn_energies.t()

        # Return the softmax normalized probability scores (with added dimension)
        return F.softmax(attn_energies, dim=1).unsqueeze(1)

现在我们已经定义了注意力子模块，我们可以实现实际的解码器模型。对于解码器，我们将一次手动输入一批数据。这意味着我们的嵌入单词张量和 GRU 输出都将具有形状(1, batch_size, hidden_size)。

计算图

  1. 获取当前输入单词的嵌入。

  2. 通过单向 GRU 进行前向传播。

  3. 根据（2）中的当前 GRU 输出计算注意力权重。

  4. 将注意力权重乘以编码器输出，得到新的“加权和”上下文向量。

  5. 使用 Luong 方程 5 连接加权上下文向量和 GRU 输出。

  6. 使用 Luong 方程 6（不带 softmax）预测下一个单词。

  7. 返回输出和最终隐藏状态。

输入

  • input_step：输入序列批次的一个时间步（一个单词）；形状=(1, batch_size)

  • last_hidden：GRU 的最终隐藏层；形状=(n_layers x num_directions, batch_size, hidden_size)

  • encoder_outputs：编码器模型的输出；形状=(max_length, batch_size, hidden_size)

输出

  • output：softmax 归一化张量，给出每个单词作为解码序列中正确下一个单词的概率；形状=(batch_size, voc.num_words)

  • hidden：GRU 的最终隐藏状态；形状=(n_layers x num_directions, batch_size, hidden_size)

class LuongAttnDecoderRNN(nn.Module):
    def __init__(self, attn_model, embedding, hidden_size, output_size, n_layers=1, dropout=0.1):
        super(LuongAttnDecoderRNN, self).__init__()

        # Keep for reference
        self.attn_model = attn_model
        self.hidden_size = hidden_size
        self.output_size = output_size
        self.n_layers = n_layers
        self.dropout = dropout

        # Define layers
        self.embedding = embedding
        self.embedding_dropout = nn.Dropout(dropout)
        self.gru = nn.GRU(hidden_size, hidden_size, n_layers, dropout=(0 if n_layers == 1 else dropout))
        self.concat = nn.Linear(hidden_size * 2, hidden_size)
        self.out = nn.Linear(hidden_size, output_size)

        self.attn = Attn(attn_model, hidden_size)

    def forward(self, input_step, last_hidden, encoder_outputs):
        # Note: we run this one step (word) at a time
        # Get embedding of current input word
        embedded = self.embedding(input_step)
        embedded = self.embedding_dropout(embedded)
        # Forward through unidirectional GRU
        rnn_output, hidden = self.gru(embedded, last_hidden)
        # Calculate attention weights from the current GRU output
        attn_weights = self.attn(rnn_output, encoder_outputs)
        # Multiply attention weights to encoder outputs to get new "weighted sum" context vector
        context = attn_weights.bmm(encoder_outputs.transpose(0, 1))
        # Concatenate weighted context vector and GRU output using Luong eq. 5
        rnn_output = rnn_output.squeeze(0)
        context = context.squeeze(1)
        concat_input = torch.cat((rnn_output, context), 1)
        concat_output = torch.tanh(self.concat(concat_input))
        # Predict next word using Luong eq. 6
        output = self.out(concat_output)
        output = F.softmax(output, dim=1)
        # Return output and final hidden state
        return output, hidden

定义训练过程#

掩码损失#

由于我们处理的是填充序列的批次，因此不能简单地考虑张量的所有元素来计算损失。我们定义 maskNLLLoss 来根据解码器的输出张量、目标张量以及描述目标张量填充的二值掩码张量来计算我们的损失。此损失函数计算掩码张量中对应于 *1* 的元素的平均负对数似然。

def maskNLLLoss(inp, target, mask):
    nTotal = mask.sum()
    crossEntropy = -torch.log(torch.gather(inp, 1, target.view(-1, 1)).squeeze(1))
    loss = crossEntropy.masked_select(mask).mean()
    loss = loss.to(device)
    return loss, nTotal.item()

单次训练迭代#

train 函数包含单次训练迭代（单个输入批次）的算法。

我们将使用一些巧妙的技巧来帮助模型收敛。

  • 第一个技巧是使用**教师强制**。这意味着在由 teacher_forcing_ratio 设置的某个概率下，我们将当前目标单词用作解码器的下一个输入，而不是使用解码器当前的猜测。此技术充当解码器的“辅助轮”，有助于更有效地进行训练。但是，教师强制可能会导致模型在推理过程中不稳定，因为解码器在训练期间可能没有足够的机会真正生成自己的输出序列。因此，我们必须注意我们如何设置 teacher_forcing_ratio，并且不要被快速收敛所迷惑。

  • 我们实现的第二个技巧是**梯度裁剪**。这是对抗“梯度爆炸”问题的常用技术。本质上，通过将梯度裁剪或阈值化到最大值，我们可以防止梯度呈指数增长，从而导致溢出（NaN）或在成本函数中越过陡峭的悬崖。

grad_clip

图片来源： Goodfellow 等人Deep Learning。2016。 https://www.deeplearningbook.org/

操作序列

  1. 将整个输入批次通过编码器进行前向传播。

  2. 将 SOS_token 初始化为解码器输入，并将隐藏状态初始化为编码器的最终隐藏状态。

  3. 一次一个时间步地将输入批次序列通过解码器进行前向传播。

  4. 如果使用教师强制：将下一个解码器输入设置为当前目标；否则：将下一个解码器输入设置为当前解码器输出。

  5. 计算并累积损失。

  6. 执行反向传播。

  7. 裁剪梯度。

  8. 更新编码器和解码器模型的参数。

注意

PyTorch 的 RNN 模块（RNN、LSTM、GRU）可以像任何其他非循环层一样使用，只需将整个输入序列（或序列批次）传递给它们即可。我们在 encoder 中像这样使用 GRU 层。实际上，底层有一个迭代过程，循环遍历每个时间步并计算隐藏状态。或者，您可以一次运行一个时间步来处理这些模块。在这种情况下，我们在训练过程中手动循环遍历序列，就像我们必须为 decoder 模型所做的那样。只要您保持对这些模块的正确概念模型，实现顺序模型就可以非常简单。

def train(input_variable, lengths, target_variable, mask, max_target_len, encoder, decoder, embedding,
          encoder_optimizer, decoder_optimizer, batch_size, clip, max_length=MAX_LENGTH):

    # Zero gradients
    encoder_optimizer.zero_grad()
    decoder_optimizer.zero_grad()

    # Set device options
    input_variable = input_variable.to(device)
    target_variable = target_variable.to(device)
    mask = mask.to(device)
    # Lengths for RNN packing should always be on the CPU
    lengths = lengths.to("cpu")

    # Initialize variables
    loss = 0
    print_losses = []
    n_totals = 0

    # Forward pass through encoder
    encoder_outputs, encoder_hidden = encoder(input_variable, lengths)

    # Create initial decoder input (start with SOS tokens for each sentence)
    decoder_input = torch.LongTensor([[SOS_token for _ in range(batch_size)]])
    decoder_input = decoder_input.to(device)

    # Set initial decoder hidden state to the encoder's final hidden state
    decoder_hidden = encoder_hidden[:decoder.n_layers]

    # Determine if we are using teacher forcing this iteration
    use_teacher_forcing = True if random.random() < teacher_forcing_ratio else False

    # Forward batch of sequences through decoder one time step at a time
    if use_teacher_forcing:
        for t in range(max_target_len):
            decoder_output, decoder_hidden = decoder(
                decoder_input, decoder_hidden, encoder_outputs
            )
            # Teacher forcing: next input is current target
            decoder_input = target_variable[t].view(1, -1)
            # Calculate and accumulate loss
            mask_loss, nTotal = maskNLLLoss(decoder_output, target_variable[t], mask[t])
            loss += mask_loss
            print_losses.append(mask_loss.item() * nTotal)
            n_totals += nTotal
    else:
        for t in range(max_target_len):
            decoder_output, decoder_hidden = decoder(
                decoder_input, decoder_hidden, encoder_outputs
            )
            # No teacher forcing: next input is decoder's own current output
            _, topi = decoder_output.topk(1)
            decoder_input = torch.LongTensor([[topi[i][0] for i in range(batch_size)]])
            decoder_input = decoder_input.to(device)
            # Calculate and accumulate loss
            mask_loss, nTotal = maskNLLLoss(decoder_output, target_variable[t], mask[t])
            loss += mask_loss
            print_losses.append(mask_loss.item() * nTotal)
            n_totals += nTotal

    # Perform backpropagation
    loss.backward()

    # Clip gradients: gradients are modified in place
    _ = nn.utils.clip_grad_norm_(encoder.parameters(), clip)
    _ = nn.utils.clip_grad_norm_(decoder.parameters(), clip)

    # Adjust model weights
    encoder_optimizer.step()
    decoder_optimizer.step()

    return sum(print_losses) / n_totals

训练迭代#

终于到了将完整的训练过程与数据联系起来的时候了。 trainIters 函数负责在给定模型、优化器、数据等的情况下运行 *n_iterations* 次训练。此函数不言自明，因为我们已经在 train 函数中完成了繁重的工作。

需要注意的是，当保存模型时，我们保存了一个 tarball，其中包含编码器和解码器的 state_dicts（参数）、优化器的 state_dicts、损失、迭代等。以这种方式保存模型将为我们提供最大的检查点灵活性。加载检查点后，我们将能够使用模型参数进行推理，或者我们可以从上次中断的地方继续训练。

def trainIters(model_name, voc, pairs, encoder, decoder, encoder_optimizer, decoder_optimizer, embedding, encoder_n_layers, decoder_n_layers, save_dir, n_iteration, batch_size, print_every, save_every, clip, corpus_name, loadFilename):

    # Load batches for each iteration
    training_batches = [batch2TrainData(voc, [random.choice(pairs) for _ in range(batch_size)])
                      for _ in range(n_iteration)]

    # Initializations
    print('Initializing ...')
    start_iteration = 1
    print_loss = 0
    if loadFilename:
        start_iteration = checkpoint['iteration'] + 1

    # Training loop
    print("Training...")
    for iteration in range(start_iteration, n_iteration + 1):
        training_batch = training_batches[iteration - 1]
        # Extract fields from batch
        input_variable, lengths, target_variable, mask, max_target_len = training_batch

        # Run a training iteration with batch
        loss = train(input_variable, lengths, target_variable, mask, max_target_len, encoder,
                     decoder, embedding, encoder_optimizer, decoder_optimizer, batch_size, clip)
        print_loss += loss

        # Print progress
        if iteration % print_every == 0:
            print_loss_avg = print_loss / print_every
            print("Iteration: {}; Percent complete: {:.1f}%; Average loss: {:.4f}".format(iteration, iteration / n_iteration * 100, print_loss_avg))
            print_loss = 0

        # Save checkpoint
        if (iteration % save_every == 0):
            directory = os.path.join(save_dir, model_name, corpus_name, '{}-{}_{}'.format(encoder_n_layers, decoder_n_layers, hidden_size))
            if not os.path.exists(directory):
                os.makedirs(directory)
            torch.save({
                'iteration': iteration,
                'en': encoder.state_dict(),
                'de': decoder.state_dict(),
                'en_opt': encoder_optimizer.state_dict(),
                'de_opt': decoder_optimizer.state_dict(),
                'loss': loss,
                'voc_dict': voc.__dict__,
                'embedding': embedding.state_dict()
            }, os.path.join(directory, '{}_{}.tar'.format(iteration, 'checkpoint')))

定义评估#

在训练完模型后，我们希望能够亲自与机器人交谈。首先，我们必须定义我们希望模型如何解码输入的编码。

贪婪解码#

贪婪解码是在我们**不**使用教师强制进行训练时所使用的解码方法。换句话说，对于每个时间步，我们只选择 decoder_output 中具有最高 softmax 值的单词。这种解码方法在单个时间步级别是最优的。

为了方便贪婪解码操作，我们定义了一个 GreedySearchDecoder 类。运行时，此类的一个对象接收一个形状为(input_seq length, 1)的输入序列（input_seq）、一个标量输入长度（input_length）张量和一个 max_length 来限制响应句子的长度。输入句子使用以下计算图进行评估：

计算图

  1. 将输入通过编码器模型进行前向传播。

  2. 准备编码器的最终隐藏层作为解码器的第一个隐藏输入。

  3. 将 SOS_token 初始化为解码器的第一个输入。

  4. 初始化用于附加已解码单词的张量。

  5. 迭代地一次解码一个单词 token

    1. 通过解码器进行前向传播。

    2. 获得最可能的单词 token 及其 softmax 分数。

    3. 记录 token 和分数。

    4. 将当前 token 准备为下一个解码器输入。

  6. 返回单词 token 和分数的集合。

class GreedySearchDecoder(nn.Module):
    def __init__(self, encoder, decoder):
        super(GreedySearchDecoder, self).__init__()
        self.encoder = encoder
        self.decoder = decoder

    def forward(self, input_seq, input_length, max_length):
        # Forward input through encoder model
        encoder_outputs, encoder_hidden = self.encoder(input_seq, input_length)
        # Prepare encoder's final hidden layer to be first hidden input to the decoder
        decoder_hidden = encoder_hidden[:self.decoder.n_layers]
        # Initialize decoder input with SOS_token
        decoder_input = torch.ones(1, 1, device=device, dtype=torch.long) * SOS_token
        # Initialize tensors to append decoded words to
        all_tokens = torch.zeros([0], device=device, dtype=torch.long)
        all_scores = torch.zeros([0], device=device)
        # Iteratively decode one word token at a time
        for _ in range(max_length):
            # Forward pass through decoder
            decoder_output, decoder_hidden = self.decoder(decoder_input, decoder_hidden, encoder_outputs)
            # Obtain most likely word token and its softmax score
            decoder_scores, decoder_input = torch.max(decoder_output, dim=1)
            # Record token and score
            all_tokens = torch.cat((all_tokens, decoder_input), dim=0)
            all_scores = torch.cat((all_scores, decoder_scores), dim=0)
            # Prepare current token to be next decoder input (add a dimension)
            decoder_input = torch.unsqueeze(decoder_input, 0)
        # Return collections of word tokens and scores
        return all_tokens, all_scores

评估我的文本#

现在我们已经定义了解码方法，我们可以编写用于评估字符串输入句子的函数。 evaluate 函数管理处理输入句子的低级过程。我们首先将句子格式化为具有 *batch_size==1* 的单词索引输入批次。我们通过将句子的单词转换为它们相应的索引，并转置维度以准备张量供我们的模型使用来实现这一点。我们还创建一个包含输入句子长度的 lengths 张量。在这种情况下，lengths 是一个标量，因为我们一次只评估一个句子（batch_size==1）。接下来，我们使用我们的 GreedySearchDecoder 对象（searcher）获取已解码的响应句子张量。最后，我们将响应的索引转换为单词，并返回已解码单词的列表。

evaluateInput 作为我们聊天机器人的用户界面。调用时，将出现一个输入文本字段，我们可以在其中输入查询句子。键入输入句子并按Enter后，我们的文本将以与训练数据相同的方式进行规范化，并最终馈送到 evaluate 函数以获取已解码的输出句子。我们循环此过程，以便我们可以继续与我们的机器人聊天，直到我们输入“q”或“quit”。

最后，如果输入的句子包含词汇表中不存在的单词，我们会优雅地处理它，打印错误消息并提示用户输入另一个句子。

def evaluate(encoder, decoder, searcher, voc, sentence, max_length=MAX_LENGTH):
    ### Format input sentence as a batch
    # words -> indexes
    indexes_batch = [indexesFromSentence(voc, sentence)]
    # Create lengths tensor
    lengths = torch.tensor([len(indexes) for indexes in indexes_batch])
    # Transpose dimensions of batch to match models' expectations
    input_batch = torch.LongTensor(indexes_batch).transpose(0, 1)
    # Use appropriate device
    input_batch = input_batch.to(device)
    lengths = lengths.to("cpu")
    # Decode sentence with searcher
    tokens, scores = searcher(input_batch, lengths, max_length)
    # indexes -> words
    decoded_words = [voc.index2word[token.item()] for token in tokens]
    return decoded_words


def evaluateInput(encoder, decoder, searcher, voc):
    input_sentence = ''
    while(1):
        try:
            # Get input sentence
            input_sentence = input('> ')
            # Check if it is quit case
            if input_sentence == 'q' or input_sentence == 'quit': break
            # Normalize sentence
            input_sentence = normalizeString(input_sentence)
            # Evaluate sentence
            output_words = evaluate(encoder, decoder, searcher, voc, input_sentence)
            # Format and print response sentence
            output_words[:] = [x for x in output_words if not (x == 'EOS' or x == 'PAD')]
            print('Bot:', ' '.join(output_words))

        except KeyError:
            print("Error: Encountered unknown word.")

运行模型#

最后，是时候运行我们的模型了！

无论我们是想训练还是测试聊天机器人模型，都必须初始化各个编码器和解码器模型。在下面的代码块中，我们设置了所需的配置，选择从头开始或设置要加载的检查点，然后构建并初始化模型。请随意尝试不同的模型配置以优化性能。

# Configure models
model_name = 'cb_model'
attn_model = 'dot'
#``attn_model = 'general'``
#``attn_model = 'concat'``
hidden_size = 500
encoder_n_layers = 2
decoder_n_layers = 2
dropout = 0.1
batch_size = 64

# Set checkpoint to load from; set to None if starting from scratch
loadFilename = None
checkpoint_iter = 4000

从检查点加载的示例代码

loadFilename = os.path.join(save_dir, model_name, corpus_name,
                    '{}-{}_{}'.format(encoder_n_layers, decoder_n_layers, hidden_size),
                    '{}_checkpoint.tar'.format(checkpoint_iter))

# Load model if a ``loadFilename`` is provided
if loadFilename:
    # If loading on same machine the model was trained on
    checkpoint = torch.load(loadFilename)
    # If loading a model trained on GPU to CPU
    #checkpoint = torch.load(loadFilename, map_location=torch.device('cpu'))
    encoder_sd = checkpoint['en']
    decoder_sd = checkpoint['de']
    encoder_optimizer_sd = checkpoint['en_opt']
    decoder_optimizer_sd = checkpoint['de_opt']
    embedding_sd = checkpoint['embedding']
    voc.__dict__ = checkpoint['voc_dict']


print('Building encoder and decoder ...')
# Initialize word embeddings
embedding = nn.Embedding(voc.num_words, hidden_size)
if loadFilename:
    embedding.load_state_dict(embedding_sd)
# Initialize encoder & decoder models
encoder = EncoderRNN(hidden_size, embedding, encoder_n_layers, dropout)
decoder = LuongAttnDecoderRNN(attn_model, embedding, hidden_size, voc.num_words, decoder_n_layers, dropout)
if loadFilename:
    encoder.load_state_dict(encoder_sd)
    decoder.load_state_dict(decoder_sd)
# Use appropriate device
encoder = encoder.to(device)
decoder = decoder.to(device)
print('Models built and ready to go!')

Building encoder and decoder ...
Models built and ready to go!

运行训练#

如果您想训练模型，请运行以下代码块。

首先，我们设置训练参数，然后初始化优化器，最后调用 trainIters 函数来运行我们的训练迭代。

# Configure training/optimization
clip = 50.0
teacher_forcing_ratio = 1.0
learning_rate = 0.0001
decoder_learning_ratio = 5.0
n_iteration = 4000
print_every = 1
save_every = 500

# Ensure dropout layers are in train mode
encoder.train()
decoder.train()

# Initialize optimizers
print('Building optimizers ...')
encoder_optimizer = optim.Adam(encoder.parameters(), lr=learning_rate)
decoder_optimizer = optim.Adam(decoder.parameters(), lr=learning_rate * decoder_learning_ratio)
if loadFilename:
    encoder_optimizer.load_state_dict(encoder_optimizer_sd)
    decoder_optimizer.load_state_dict(decoder_optimizer_sd)

# If you have an accelerator, configure it to call
for state in encoder_optimizer.state.values():
    for k, v in state.items():
        if isinstance(v, torch.Tensor):
            state[k] = v.to(device)

for state in decoder_optimizer.state.values():
    for k, v in state.items():
        if isinstance(v, torch.Tensor):
            state[k] = v.to(device)

# Run training iterations
print("Starting Training!")
trainIters(model_name, voc, pairs, encoder, decoder, encoder_optimizer, decoder_optimizer,
           embedding, encoder_n_layers, decoder_n_layers, save_dir, n_iteration, batch_size,
           print_every, save_every, clip, corpus_name, loadFilename)

Building optimizers ...
Starting Training!
Initializing ...
Training...
Iteration: 1; Percent complete: 0.0%; Average loss: 8.9636
Iteration: 2; Percent complete: 0.1%; Average loss: 8.8313
Iteration: 3; Percent complete: 0.1%; Average loss: 8.6581
Iteration: 4; Percent complete: 0.1%; Average loss: 8.2725
Iteration: 5; Percent complete: 0.1%; Average loss: 7.9226
Iteration: 6; Percent complete: 0.1%; Average loss: 7.3283
Iteration: 7; Percent complete: 0.2%; Average loss: 6.9254
Iteration: 8; Percent complete: 0.2%; Average loss: 6.6599
Iteration: 9; Percent complete: 0.2%; Average loss: 6.5629
Iteration: 10; Percent complete: 0.2%; Average loss: 6.5117
Iteration: 11; Percent complete: 0.3%; Average loss: 6.2220
Iteration: 12; Percent complete: 0.3%; Average loss: 5.9812
Iteration: 13; Percent complete: 0.3%; Average loss: 5.9450
Iteration: 14; Percent complete: 0.4%; Average loss: 5.7474
Iteration: 15; Percent complete: 0.4%; Average loss: 5.6762
Iteration: 16; Percent complete: 0.4%; Average loss: 5.3747
Iteration: 17; Percent complete: 0.4%; Average loss: 5.1390
Iteration: 18; Percent complete: 0.4%; Average loss: 5.2316
Iteration: 19; Percent complete: 0.5%; Average loss: 4.9768
Iteration: 20; Percent complete: 0.5%; Average loss: 4.9931
Iteration: 21; Percent complete: 0.5%; Average loss: 4.9274
Iteration: 22; Percent complete: 0.5%; Average loss: 5.0186
Iteration: 23; Percent complete: 0.6%; Average loss: 4.9807
Iteration: 24; Percent complete: 0.6%; Average loss: 4.9375
Iteration: 25; Percent complete: 0.6%; Average loss: 5.0517
Iteration: 26; Percent complete: 0.7%; Average loss: 5.0525
Iteration: 27; Percent complete: 0.7%; Average loss: 5.0630
Iteration: 28; Percent complete: 0.7%; Average loss: 4.6687
Iteration: 29; Percent complete: 0.7%; Average loss: 4.6478
Iteration: 30; Percent complete: 0.8%; Average loss: 4.7522
Iteration: 31; Percent complete: 0.8%; Average loss: 4.9685
Iteration: 32; Percent complete: 0.8%; Average loss: 4.8710
Iteration: 33; Percent complete: 0.8%; Average loss: 4.7697
Iteration: 34; Percent complete: 0.9%; Average loss: 4.7266
Iteration: 35; Percent complete: 0.9%; Average loss: 4.8286
Iteration: 36; Percent complete: 0.9%; Average loss: 4.9682
Iteration: 37; Percent complete: 0.9%; Average loss: 4.9386
Iteration: 38; Percent complete: 0.9%; Average loss: 4.7891
Iteration: 39; Percent complete: 1.0%; Average loss: 4.7858
Iteration: 40; Percent complete: 1.0%; Average loss: 4.7050
Iteration: 41; Percent complete: 1.0%; Average loss: 4.7227
Iteration: 42; Percent complete: 1.1%; Average loss: 4.8539
Iteration: 43; Percent complete: 1.1%; Average loss: 4.8597
Iteration: 44; Percent complete: 1.1%; Average loss: 4.5262
Iteration: 45; Percent complete: 1.1%; Average loss: 4.6508
Iteration: 46; Percent complete: 1.1%; Average loss: 4.8285
Iteration: 47; Percent complete: 1.2%; Average loss: 4.5819
Iteration: 48; Percent complete: 1.2%; Average loss: 4.6844
Iteration: 49; Percent complete: 1.2%; Average loss: 4.6983
Iteration: 50; Percent complete: 1.2%; Average loss: 4.7229
Iteration: 51; Percent complete: 1.3%; Average loss: 4.4266
Iteration: 52; Percent complete: 1.3%; Average loss: 4.7121
Iteration: 53; Percent complete: 1.3%; Average loss: 4.5898
Iteration: 54; Percent complete: 1.4%; Average loss: 4.6904
Iteration: 55; Percent complete: 1.4%; Average loss: 4.8149
Iteration: 56; Percent complete: 1.4%; Average loss: 4.5183
Iteration: 57; Percent complete: 1.4%; Average loss: 4.5077
Iteration: 58; Percent complete: 1.5%; Average loss: 4.4994
Iteration: 59; Percent complete: 1.5%; Average loss: 4.6849
Iteration: 60; Percent complete: 1.5%; Average loss: 4.7306
Iteration: 61; Percent complete: 1.5%; Average loss: 4.5112
Iteration: 62; Percent complete: 1.6%; Average loss: 4.8184
Iteration: 63; Percent complete: 1.6%; Average loss: 4.6478
Iteration: 64; Percent complete: 1.6%; Average loss: 4.8283
Iteration: 65; Percent complete: 1.6%; Average loss: 4.5789
Iteration: 66; Percent complete: 1.7%; Average loss: 4.2820
Iteration: 67; Percent complete: 1.7%; Average loss: 4.7813
Iteration: 68; Percent complete: 1.7%; Average loss: 4.7474
Iteration: 69; Percent complete: 1.7%; Average loss: 4.3980
Iteration: 70; Percent complete: 1.8%; Average loss: 4.4391
Iteration: 71; Percent complete: 1.8%; Average loss: 4.4420
Iteration: 72; Percent complete: 1.8%; Average loss: 4.4624
Iteration: 73; Percent complete: 1.8%; Average loss: 4.5743
Iteration: 74; Percent complete: 1.8%; Average loss: 4.5554
Iteration: 75; Percent complete: 1.9%; Average loss: 4.5365
Iteration: 76; Percent complete: 1.9%; Average loss: 4.5938
Iteration: 77; Percent complete: 1.9%; Average loss: 4.3348
Iteration: 78; Percent complete: 1.9%; Average loss: 4.6910
Iteration: 79; Percent complete: 2.0%; Average loss: 4.4926
Iteration: 80; Percent complete: 2.0%; Average loss: 4.4112
Iteration: 81; Percent complete: 2.0%; Average loss: 4.4939
Iteration: 82; Percent complete: 2.1%; Average loss: 4.5741
Iteration: 83; Percent complete: 2.1%; Average loss: 4.5178
Iteration: 84; Percent complete: 2.1%; Average loss: 4.3083
Iteration: 85; Percent complete: 2.1%; Average loss: 4.4833
Iteration: 86; Percent complete: 2.1%; Average loss: 4.5240
Iteration: 87; Percent complete: 2.2%; Average loss: 4.5519
Iteration: 88; Percent complete: 2.2%; Average loss: 4.5280
Iteration: 89; Percent complete: 2.2%; Average loss: 4.4399
Iteration: 90; Percent complete: 2.2%; Average loss: 4.4387
Iteration: 91; Percent complete: 2.3%; Average loss: 4.4504
Iteration: 92; Percent complete: 2.3%; Average loss: 4.4118
Iteration: 93; Percent complete: 2.3%; Average loss: 4.2436
Iteration: 94; Percent complete: 2.4%; Average loss: 4.5039
Iteration: 95; Percent complete: 2.4%; Average loss: 4.7371
Iteration: 96; Percent complete: 2.4%; Average loss: 4.4701
Iteration: 97; Percent complete: 2.4%; Average loss: 4.6615
Iteration: 98; Percent complete: 2.5%; Average loss: 4.4491
Iteration: 99; Percent complete: 2.5%; Average loss: 4.4849
Iteration: 100; Percent complete: 2.5%; Average loss: 4.2803
Iteration: 101; Percent complete: 2.5%; Average loss: 4.5781
Iteration: 102; Percent complete: 2.5%; Average loss: 4.4069
Iteration: 103; Percent complete: 2.6%; Average loss: 4.0891
Iteration: 104; Percent complete: 2.6%; Average loss: 4.4922
Iteration: 105; Percent complete: 2.6%; Average loss: 4.1932
Iteration: 106; Percent complete: 2.6%; Average loss: 4.4610
Iteration: 107; Percent complete: 2.7%; Average loss: 4.3623
Iteration: 108; Percent complete: 2.7%; Average loss: 4.6201
Iteration: 109; Percent complete: 2.7%; Average loss: 4.3136
Iteration: 110; Percent complete: 2.8%; Average loss: 4.4397
Iteration: 111; Percent complete: 2.8%; Average loss: 4.5106
Iteration: 112; Percent complete: 2.8%; Average loss: 4.4162
Iteration: 113; Percent complete: 2.8%; Average loss: 4.4058
Iteration: 114; Percent complete: 2.9%; Average loss: 4.3092
Iteration: 115; Percent complete: 2.9%; Average loss: 4.4110
Iteration: 116; Percent complete: 2.9%; Average loss: 4.3312
Iteration: 117; Percent complete: 2.9%; Average loss: 4.5593
Iteration: 118; Percent complete: 2.9%; Average loss: 4.2946
Iteration: 119; Percent complete: 3.0%; Average loss: 4.2876
Iteration: 120; Percent complete: 3.0%; Average loss: 4.5015
Iteration: 121; Percent complete: 3.0%; Average loss: 4.2795
Iteration: 122; Percent complete: 3.0%; Average loss: 4.4189
Iteration: 123; Percent complete: 3.1%; Average loss: 4.4515
Iteration: 124; Percent complete: 3.1%; Average loss: 4.4198
Iteration: 125; Percent complete: 3.1%; Average loss: 4.5719
Iteration: 126; Percent complete: 3.1%; Average loss: 4.3101
Iteration: 127; Percent complete: 3.2%; Average loss: 4.3026
Iteration: 128; Percent complete: 3.2%; Average loss: 4.2357
Iteration: 129; Percent complete: 3.2%; Average loss: 4.2856
Iteration: 130; Percent complete: 3.2%; Average loss: 4.3964
Iteration: 131; Percent complete: 3.3%; Average loss: 4.2642
Iteration: 132; Percent complete: 3.3%; Average loss: 3.8943
Iteration: 133; Percent complete: 3.3%; Average loss: 3.9957
Iteration: 134; Percent complete: 3.4%; Average loss: 4.1629
Iteration: 135; Percent complete: 3.4%; Average loss: 4.5063
Iteration: 136; Percent complete: 3.4%; Average loss: 4.2987
Iteration: 137; Percent complete: 3.4%; Average loss: 4.5523
Iteration: 138; Percent complete: 3.5%; Average loss: 4.4045
Iteration: 139; Percent complete: 3.5%; Average loss: 4.3533
Iteration: 140; Percent complete: 3.5%; Average loss: 4.5834
Iteration: 141; Percent complete: 3.5%; Average loss: 4.1530
Iteration: 142; Percent complete: 3.5%; Average loss: 4.1735
Iteration: 143; Percent complete: 3.6%; Average loss: 4.2615
Iteration: 144; Percent complete: 3.6%; Average loss: 4.4184
Iteration: 145; Percent complete: 3.6%; Average loss: 4.4300
Iteration: 146; Percent complete: 3.6%; Average loss: 4.3787
Iteration: 147; Percent complete: 3.7%; Average loss: 4.2749
Iteration: 148; Percent complete: 3.7%; Average loss: 3.9847
Iteration: 149; Percent complete: 3.7%; Average loss: 4.4000
Iteration: 150; Percent complete: 3.8%; Average loss: 4.3535
Iteration: 151; Percent complete: 3.8%; Average loss: 4.2118
Iteration: 152; Percent complete: 3.8%; Average loss: 4.3036
Iteration: 153; Percent complete: 3.8%; Average loss: 4.1405
Iteration: 154; Percent complete: 3.9%; Average loss: 4.1459
Iteration: 155; Percent complete: 3.9%; Average loss: 4.0592
Iteration: 156; Percent complete: 3.9%; Average loss: 4.1635
Iteration: 157; Percent complete: 3.9%; Average loss: 4.2796
Iteration: 158; Percent complete: 4.0%; Average loss: 4.2391
Iteration: 159; Percent complete: 4.0%; Average loss: 4.3601
Iteration: 160; Percent complete: 4.0%; Average loss: 3.9695
Iteration: 161; Percent complete: 4.0%; Average loss: 4.3025
Iteration: 162; Percent complete: 4.0%; Average loss: 4.0594
Iteration: 163; Percent complete: 4.1%; Average loss: 4.3165
Iteration: 164; Percent complete: 4.1%; Average loss: 4.1809
Iteration: 165; Percent complete: 4.1%; Average loss: 4.0224
Iteration: 166; Percent complete: 4.2%; Average loss: 4.2015
Iteration: 167; Percent complete: 4.2%; Average loss: 4.3993
Iteration: 168; Percent complete: 4.2%; Average loss: 4.3080
Iteration: 169; Percent complete: 4.2%; Average loss: 4.1988
Iteration: 170; Percent complete: 4.2%; Average loss: 4.1355
Iteration: 171; Percent complete: 4.3%; Average loss: 4.1842
Iteration: 172; Percent complete: 4.3%; Average loss: 4.4067
Iteration: 173; Percent complete: 4.3%; Average loss: 4.2898
Iteration: 174; Percent complete: 4.3%; Average loss: 4.3039
Iteration: 175; Percent complete: 4.4%; Average loss: 4.1532
Iteration: 176; Percent complete: 4.4%; Average loss: 3.9877
Iteration: 177; Percent complete: 4.4%; Average loss: 4.0167
Iteration: 178; Percent complete: 4.5%; Average loss: 3.9475
Iteration: 179; Percent complete: 4.5%; Average loss: 4.1835
Iteration: 180; Percent complete: 4.5%; Average loss: 4.4099
Iteration: 181; Percent complete: 4.5%; Average loss: 4.4395
Iteration: 182; Percent complete: 4.5%; Average loss: 4.0188
Iteration: 183; Percent complete: 4.6%; Average loss: 4.2495
Iteration: 184; Percent complete: 4.6%; Average loss: 4.1611
Iteration: 185; Percent complete: 4.6%; Average loss: 4.3865
Iteration: 186; Percent complete: 4.7%; Average loss: 4.0871
Iteration: 187; Percent complete: 4.7%; Average loss: 4.2351
Iteration: 188; Percent complete: 4.7%; Average loss: 3.9684
Iteration: 189; Percent complete: 4.7%; Average loss: 4.4671
Iteration: 190; Percent complete: 4.8%; Average loss: 4.2609
Iteration: 191; Percent complete: 4.8%; Average loss: 4.1297
Iteration: 192; Percent complete: 4.8%; Average loss: 4.1708
Iteration: 193; Percent complete: 4.8%; Average loss: 4.0272
Iteration: 194; Percent complete: 4.9%; Average loss: 4.1511
Iteration: 195; Percent complete: 4.9%; Average loss: 4.0897
Iteration: 196; Percent complete: 4.9%; Average loss: 3.9471
Iteration: 197; Percent complete: 4.9%; Average loss: 4.2495
Iteration: 198; Percent complete: 5.0%; Average loss: 4.1860
Iteration: 199; Percent complete: 5.0%; Average loss: 3.9979
Iteration: 200; Percent complete: 5.0%; Average loss: 3.8809
Iteration: 201; Percent complete: 5.0%; Average loss: 4.2186
Iteration: 202; Percent complete: 5.1%; Average loss: 4.3366
Iteration: 203; Percent complete: 5.1%; Average loss: 4.0707
Iteration: 204; Percent complete: 5.1%; Average loss: 4.1218
Iteration: 205; Percent complete: 5.1%; Average loss: 3.8812
Iteration: 206; Percent complete: 5.1%; Average loss: 4.0558
Iteration: 207; Percent complete: 5.2%; Average loss: 4.0501
Iteration: 208; Percent complete: 5.2%; Average loss: 4.0757
Iteration: 209; Percent complete: 5.2%; Average loss: 3.9434
Iteration: 210; Percent complete: 5.2%; Average loss: 3.7664
Iteration: 211; Percent complete: 5.3%; Average loss: 3.9357
Iteration: 212; Percent complete: 5.3%; Average loss: 4.3763
Iteration: 213; Percent complete: 5.3%; Average loss: 4.2333
Iteration: 214; Percent complete: 5.3%; Average loss: 4.0965
Iteration: 215; Percent complete: 5.4%; Average loss: 3.8343
Iteration: 216; Percent complete: 5.4%; Average loss: 3.7086
Iteration: 217; Percent complete: 5.4%; Average loss: 4.3028
Iteration: 218; Percent complete: 5.5%; Average loss: 4.1869
Iteration: 219; Percent complete: 5.5%; Average loss: 4.0864
Iteration: 220; Percent complete: 5.5%; Average loss: 3.9577
Iteration: 221; Percent complete: 5.5%; Average loss: 3.9617
Iteration: 222; Percent complete: 5.5%; Average loss: 3.9971
Iteration: 223; Percent complete: 5.6%; Average loss: 3.7839
Iteration: 224; Percent complete: 5.6%; Average loss: 3.9297
Iteration: 225; Percent complete: 5.6%; Average loss: 4.2698
Iteration: 226; Percent complete: 5.7%; Average loss: 4.1036
Iteration: 227; Percent complete: 5.7%; Average loss: 4.1896
Iteration: 228; Percent complete: 5.7%; Average loss: 3.9086
Iteration: 229; Percent complete: 5.7%; Average loss: 3.7855
Iteration: 230; Percent complete: 5.8%; Average loss: 3.6887
Iteration: 231; Percent complete: 5.8%; Average loss: 4.0187
Iteration: 232; Percent complete: 5.8%; Average loss: 3.9063
Iteration: 233; Percent complete: 5.8%; Average loss: 4.0903
Iteration: 234; Percent complete: 5.9%; Average loss: 4.0305
Iteration: 235; Percent complete: 5.9%; Average loss: 4.1664
Iteration: 236; Percent complete: 5.9%; Average loss: 4.1239
Iteration: 237; Percent complete: 5.9%; Average loss: 3.8724
Iteration: 238; Percent complete: 5.9%; Average loss: 3.9636
Iteration: 239; Percent complete: 6.0%; Average loss: 4.2023
Iteration: 240; Percent complete: 6.0%; Average loss: 4.1441
Iteration: 241; Percent complete: 6.0%; Average loss: 4.1056
Iteration: 242; Percent complete: 6.0%; Average loss: 3.8382
Iteration: 243; Percent complete: 6.1%; Average loss: 3.8419
Iteration: 244; Percent complete: 6.1%; Average loss: 4.2301
Iteration: 245; Percent complete: 6.1%; Average loss: 4.0734
Iteration: 246; Percent complete: 6.2%; Average loss: 3.9312
Iteration: 247; Percent complete: 6.2%; Average loss: 3.8807
Iteration: 248; Percent complete: 6.2%; Average loss: 4.1320
Iteration: 249; Percent complete: 6.2%; Average loss: 3.9059
Iteration: 250; Percent complete: 6.2%; Average loss: 3.6572
Iteration: 251; Percent complete: 6.3%; Average loss: 4.1304
Iteration: 252; Percent complete: 6.3%; Average loss: 3.8158
Iteration: 253; Percent complete: 6.3%; Average loss: 3.8639
Iteration: 254; Percent complete: 6.3%; Average loss: 4.0487
Iteration: 255; Percent complete: 6.4%; Average loss: 3.9538
Iteration: 256; Percent complete: 6.4%; Average loss: 3.8879
Iteration: 257; Percent complete: 6.4%; Average loss: 3.8577
Iteration: 258; Percent complete: 6.5%; Average loss: 3.8389
Iteration: 259; Percent complete: 6.5%; Average loss: 3.9338
Iteration: 260; Percent complete: 6.5%; Average loss: 3.7612
Iteration: 261; Percent complete: 6.5%; Average loss: 3.9677
Iteration: 262; Percent complete: 6.6%; Average loss: 3.9856
Iteration: 263; Percent complete: 6.6%; Average loss: 3.9244
Iteration: 264; Percent complete: 6.6%; Average loss: 3.7804
Iteration: 265; Percent complete: 6.6%; Average loss: 3.8185
Iteration: 266; Percent complete: 6.7%; Average loss: 4.0429
Iteration: 267; Percent complete: 6.7%; Average loss: 4.1593
Iteration: 268; Percent complete: 6.7%; Average loss: 3.9855
Iteration: 269; Percent complete: 6.7%; Average loss: 4.0174
Iteration: 270; Percent complete: 6.8%; Average loss: 4.1623
Iteration: 271; Percent complete: 6.8%; Average loss: 4.0245
Iteration: 272; Percent complete: 6.8%; Average loss: 4.0824
Iteration: 273; Percent complete: 6.8%; Average loss: 3.9129
Iteration: 274; Percent complete: 6.9%; Average loss: 3.9432
Iteration: 275; Percent complete: 6.9%; Average loss: 3.8394
Iteration: 276; Percent complete: 6.9%; Average loss: 4.2996
Iteration: 277; Percent complete: 6.9%; Average loss: 3.9722
Iteration: 278; Percent complete: 7.0%; Average loss: 3.8118
Iteration: 279; Percent complete: 7.0%; Average loss: 3.8013
Iteration: 280; Percent complete: 7.0%; Average loss: 4.0696
Iteration: 281; Percent complete: 7.0%; Average loss: 3.6854
Iteration: 282; Percent complete: 7.0%; Average loss: 3.8799
Iteration: 283; Percent complete: 7.1%; Average loss: 3.8450
Iteration: 284; Percent complete: 7.1%; Average loss: 3.6209
Iteration: 285; Percent complete: 7.1%; Average loss: 3.7942
Iteration: 286; Percent complete: 7.1%; Average loss: 3.9372
Iteration: 287; Percent complete: 7.2%; Average loss: 4.0170
Iteration: 288; Percent complete: 7.2%; Average loss: 4.0383
Iteration: 289; Percent complete: 7.2%; Average loss: 4.0446
Iteration: 290; Percent complete: 7.2%; Average loss: 4.2003
Iteration: 291; Percent complete: 7.3%; Average loss: 4.2163
Iteration: 292; Percent complete: 7.3%; Average loss: 4.0547
Iteration: 293; Percent complete: 7.3%; Average loss: 3.7187
Iteration: 294; Percent complete: 7.3%; Average loss: 3.8356
Iteration: 295; Percent complete: 7.4%; Average loss: 3.7154
Iteration: 296; Percent complete: 7.4%; Average loss: 4.0915
Iteration: 297; Percent complete: 7.4%; Average loss: 4.0231
Iteration: 298; Percent complete: 7.4%; Average loss: 3.8031
Iteration: 299; Percent complete: 7.5%; Average loss: 3.9805
Iteration: 300; Percent complete: 7.5%; Average loss: 4.2603
Iteration: 301; Percent complete: 7.5%; Average loss: 3.9566
Iteration: 302; Percent complete: 7.5%; Average loss: 3.9662
Iteration: 303; Percent complete: 7.6%; Average loss: 3.8608
Iteration: 304; Percent complete: 7.6%; Average loss: 3.8439
Iteration: 305; Percent complete: 7.6%; Average loss: 4.1489
Iteration: 306; Percent complete: 7.6%; Average loss: 3.7840
Iteration: 307; Percent complete: 7.7%; Average loss: 3.8458
Iteration: 308; Percent complete: 7.7%; Average loss: 3.9981
Iteration: 309; Percent complete: 7.7%; Average loss: 4.0850
Iteration: 310; Percent complete: 7.8%; Average loss: 3.9528
Iteration: 311; Percent complete: 7.8%; Average loss: 4.1173
Iteration: 312; Percent complete: 7.8%; Average loss: 3.9922
Iteration: 313; Percent complete: 7.8%; Average loss: 3.8504
Iteration: 314; Percent complete: 7.8%; Average loss: 3.8157
Iteration: 315; Percent complete: 7.9%; Average loss: 3.9365
Iteration: 316; Percent complete: 7.9%; Average loss: 4.1556
Iteration: 317; Percent complete: 7.9%; Average loss: 4.0244
Iteration: 318; Percent complete: 8.0%; Average loss: 3.8088
Iteration: 319; Percent complete: 8.0%; Average loss: 3.8671
Iteration: 320; Percent complete: 8.0%; Average loss: 3.6664
Iteration: 321; Percent complete: 8.0%; Average loss: 4.1603
Iteration: 322; Percent complete: 8.1%; Average loss: 3.7484
Iteration: 323; Percent complete: 8.1%; Average loss: 3.6973
Iteration: 324; Percent complete: 8.1%; Average loss: 3.7960
Iteration: 325; Percent complete: 8.1%; Average loss: 4.1484
Iteration: 326; Percent complete: 8.2%; Average loss: 3.8513
Iteration: 327; Percent complete: 8.2%; Average loss: 3.9528
Iteration: 328; Percent complete: 8.2%; Average loss: 4.0718
Iteration: 329; Percent complete: 8.2%; Average loss: 3.7847
Iteration: 330; Percent complete: 8.2%; Average loss: 3.6424
Iteration: 331; Percent complete: 8.3%; Average loss: 3.9672
Iteration: 332; Percent complete: 8.3%; Average loss: 4.2551
Iteration: 333; Percent complete: 8.3%; Average loss: 3.8377
Iteration: 334; Percent complete: 8.3%; Average loss: 3.7914
Iteration: 335; Percent complete: 8.4%; Average loss: 3.7914
Iteration: 336; Percent complete: 8.4%; Average loss: 4.1176
Iteration: 337; Percent complete: 8.4%; Average loss: 3.6615
Iteration: 338; Percent complete: 8.5%; Average loss: 3.7038
Iteration: 339; Percent complete: 8.5%; Average loss: 3.7637
Iteration: 340; Percent complete: 8.5%; Average loss: 4.0111
Iteration: 341; Percent complete: 8.5%; Average loss: 3.6843
Iteration: 342; Percent complete: 8.6%; Average loss: 4.0023
Iteration: 343; Percent complete: 8.6%; Average loss: 3.6993
Iteration: 344; Percent complete: 8.6%; Average loss: 4.0587
Iteration: 345; Percent complete: 8.6%; Average loss: 4.0350
Iteration: 346; Percent complete: 8.6%; Average loss: 3.5817
Iteration: 347; Percent complete: 8.7%; Average loss: 3.9702
Iteration: 348; Percent complete: 8.7%; Average loss: 3.7566
Iteration: 349; Percent complete: 8.7%; Average loss: 3.6596
Iteration: 350; Percent complete: 8.8%; Average loss: 3.8225
Iteration: 351; Percent complete: 8.8%; Average loss: 3.8892
Iteration: 352; Percent complete: 8.8%; Average loss: 4.1239
Iteration: 353; Percent complete: 8.8%; Average loss: 3.7801
Iteration: 354; Percent complete: 8.8%; Average loss: 4.1708
Iteration: 355; Percent complete: 8.9%; Average loss: 3.7441
Iteration: 356; Percent complete: 8.9%; Average loss: 3.8402
Iteration: 357; Percent complete: 8.9%; Average loss: 3.6044
Iteration: 358; Percent complete: 8.9%; Average loss: 3.7062
Iteration: 359; Percent complete: 9.0%; Average loss: 3.7888
Iteration: 360; Percent complete: 9.0%; Average loss: 3.9617
Iteration: 361; Percent complete: 9.0%; Average loss: 3.7303
Iteration: 362; Percent complete: 9.0%; Average loss: 3.9753
Iteration: 363; Percent complete: 9.1%; Average loss: 3.7461
Iteration: 364; Percent complete: 9.1%; Average loss: 3.8818
Iteration: 365; Percent complete: 9.1%; Average loss: 3.6979
Iteration: 366; Percent complete: 9.2%; Average loss: 3.9812
Iteration: 367; Percent complete: 9.2%; Average loss: 3.7647
Iteration: 368; Percent complete: 9.2%; Average loss: 3.7670
Iteration: 369; Percent complete: 9.2%; Average loss: 3.7979
Iteration: 370; Percent complete: 9.2%; Average loss: 3.7923
Iteration: 371; Percent complete: 9.3%; Average loss: 4.3305
Iteration: 372; Percent complete: 9.3%; Average loss: 3.7388
Iteration: 373; Percent complete: 9.3%; Average loss: 4.0242
Iteration: 374; Percent complete: 9.3%; Average loss: 3.8018
Iteration: 375; Percent complete: 9.4%; Average loss: 3.9413
Iteration: 376; Percent complete: 9.4%; Average loss: 3.7064
Iteration: 377; Percent complete: 9.4%; Average loss: 3.9064
Iteration: 378; Percent complete: 9.4%; Average loss: 3.6743
Iteration: 379; Percent complete: 9.5%; Average loss: 3.6788
Iteration: 380; Percent complete: 9.5%; Average loss: 3.7493
Iteration: 381; Percent complete: 9.5%; Average loss: 3.4731
Iteration: 382; Percent complete: 9.6%; Average loss: 3.9488
Iteration: 383; Percent complete: 9.6%; Average loss: 3.8631
Iteration: 384; Percent complete: 9.6%; Average loss: 4.1793
Iteration: 385; Percent complete: 9.6%; Average loss: 3.4189
Iteration: 386; Percent complete: 9.7%; Average loss: 3.8420
Iteration: 387; Percent complete: 9.7%; Average loss: 4.0068
Iteration: 388; Percent complete: 9.7%; Average loss: 3.9350
Iteration: 389; Percent complete: 9.7%; Average loss: 3.6937
Iteration: 390; Percent complete: 9.8%; Average loss: 3.7071
Iteration: 391; Percent complete: 9.8%; Average loss: 3.9744
Iteration: 392; Percent complete: 9.8%; Average loss: 3.9900
Iteration: 393; Percent complete: 9.8%; Average loss: 3.6713
Iteration: 394; Percent complete: 9.8%; Average loss: 3.9216
Iteration: 395; Percent complete: 9.9%; Average loss: 3.7827
Iteration: 396; Percent complete: 9.9%; Average loss: 3.8361
Iteration: 397; Percent complete: 9.9%; Average loss: 3.8758
Iteration: 398; Percent complete: 10.0%; Average loss: 3.8970
Iteration: 399; Percent complete: 10.0%; Average loss: 3.8781
Iteration: 400; Percent complete: 10.0%; Average loss: 4.1731
Iteration: 401; Percent complete: 10.0%; Average loss: 3.8854
Iteration: 402; Percent complete: 10.1%; Average loss: 3.5846
Iteration: 403; Percent complete: 10.1%; Average loss: 3.7838
Iteration: 404; Percent complete: 10.1%; Average loss: 3.7122
Iteration: 405; Percent complete: 10.1%; Average loss: 3.6550
Iteration: 406; Percent complete: 10.2%; Average loss: 3.8002
Iteration: 407; Percent complete: 10.2%; Average loss: 3.8032
Iteration: 408; Percent complete: 10.2%; Average loss: 3.9027
Iteration: 409; Percent complete: 10.2%; Average loss: 3.8555
Iteration: 410; Percent complete: 10.2%; Average loss: 4.0888
Iteration: 411; Percent complete: 10.3%; Average loss: 3.8975
Iteration: 412; Percent complete: 10.3%; Average loss: 3.7005
Iteration: 413; Percent complete: 10.3%; Average loss: 3.7737
Iteration: 414; Percent complete: 10.3%; Average loss: 3.8863
Iteration: 415; Percent complete: 10.4%; Average loss: 4.1185
Iteration: 416; Percent complete: 10.4%; Average loss: 3.7875
Iteration: 417; Percent complete: 10.4%; Average loss: 3.7938
Iteration: 418; Percent complete: 10.4%; Average loss: 3.6301
Iteration: 419; Percent complete: 10.5%; Average loss: 4.0663
Iteration: 420; Percent complete: 10.5%; Average loss: 3.7130
Iteration: 421; Percent complete: 10.5%; Average loss: 3.9950
Iteration: 422; Percent complete: 10.5%; Average loss: 3.9411
Iteration: 423; Percent complete: 10.6%; Average loss: 3.6338
Iteration: 424; Percent complete: 10.6%; Average loss: 3.8034
Iteration: 425; Percent complete: 10.6%; Average loss: 3.7852
Iteration: 426; Percent complete: 10.7%; Average loss: 3.4949
Iteration: 427; Percent complete: 10.7%; Average loss: 3.9568
Iteration: 428; Percent complete: 10.7%; Average loss: 4.0003
Iteration: 429; Percent complete: 10.7%; Average loss: 3.7094
Iteration: 430; Percent complete: 10.8%; Average loss: 3.7977
Iteration: 431; Percent complete: 10.8%; Average loss: 3.7829
Iteration: 432; Percent complete: 10.8%; Average loss: 3.8627
Iteration: 433; Percent complete: 10.8%; Average loss: 3.7359
Iteration: 434; Percent complete: 10.8%; Average loss: 3.7843
Iteration: 435; Percent complete: 10.9%; Average loss: 3.9011
Iteration: 436; Percent complete: 10.9%; Average loss: 3.6779
Iteration: 437; Percent complete: 10.9%; Average loss: 3.7558
Iteration: 438; Percent complete: 10.9%; Average loss: 3.9018
Iteration: 439; Percent complete: 11.0%; Average loss: 3.5099
Iteration: 440; Percent complete: 11.0%; Average loss: 4.0219
Iteration: 441; Percent complete: 11.0%; Average loss: 3.7284
Iteration: 442; Percent complete: 11.1%; Average loss: 3.8568
Iteration: 443; Percent complete: 11.1%; Average loss: 3.8547
Iteration: 444; Percent complete: 11.1%; Average loss: 3.7587
Iteration: 445; Percent complete: 11.1%; Average loss: 4.0258
Iteration: 446; Percent complete: 11.2%; Average loss: 3.9936
Iteration: 447; Percent complete: 11.2%; Average loss: 3.6567
Iteration: 448; Percent complete: 11.2%; Average loss: 3.9529
Iteration: 449; Percent complete: 11.2%; Average loss: 3.5445
Iteration: 450; Percent complete: 11.2%; Average loss: 4.0308
Iteration: 451; Percent complete: 11.3%; Average loss: 3.6604
Iteration: 452; Percent complete: 11.3%; Average loss: 4.0699
Iteration: 453; Percent complete: 11.3%; Average loss: 3.7300
Iteration: 454; Percent complete: 11.3%; Average loss: 3.5589
Iteration: 455; Percent complete: 11.4%; Average loss: 3.6280
Iteration: 456; Percent complete: 11.4%; Average loss: 3.7808
Iteration: 457; Percent complete: 11.4%; Average loss: 3.6342
Iteration: 458; Percent complete: 11.5%; Average loss: 3.7980
Iteration: 459; Percent complete: 11.5%; Average loss: 3.8012
Iteration: 460; Percent complete: 11.5%; Average loss: 3.6375
Iteration: 461; Percent complete: 11.5%; Average loss: 3.7269
Iteration: 462; Percent complete: 11.6%; Average loss: 3.7273
Iteration: 463; Percent complete: 11.6%; Average loss: 3.5827
Iteration: 464; Percent complete: 11.6%; Average loss: 3.7723
Iteration: 465; Percent complete: 11.6%; Average loss: 3.6171
Iteration: 466; Percent complete: 11.7%; Average loss: 3.7302
Iteration: 467; Percent complete: 11.7%; Average loss: 3.7993
Iteration: 468; Percent complete: 11.7%; Average loss: 3.4514
Iteration: 469; Percent complete: 11.7%; Average loss: 3.7413
Iteration: 470; Percent complete: 11.8%; Average loss: 3.7956
Iteration: 471; Percent complete: 11.8%; Average loss: 4.0601
Iteration: 472; Percent complete: 11.8%; Average loss: 3.6446
Iteration: 473; Percent complete: 11.8%; Average loss: 3.8909
Iteration: 474; Percent complete: 11.8%; Average loss: 4.0277
Iteration: 475; Percent complete: 11.9%; Average loss: 3.7424
Iteration: 476; Percent complete: 11.9%; Average loss: 3.8220
Iteration: 477; Percent complete: 11.9%; Average loss: 3.7258
Iteration: 478; Percent complete: 11.9%; Average loss: 3.6878
Iteration: 479; Percent complete: 12.0%; Average loss: 3.6235
Iteration: 480; Percent complete: 12.0%; Average loss: 3.7311
Iteration: 481; Percent complete: 12.0%; Average loss: 3.7833
Iteration: 482; Percent complete: 12.0%; Average loss: 3.6307
Iteration: 483; Percent complete: 12.1%; Average loss: 3.7141
Iteration: 484; Percent complete: 12.1%; Average loss: 3.7625
Iteration: 485; Percent complete: 12.1%; Average loss: 3.7906
Iteration: 486; Percent complete: 12.2%; Average loss: 3.6643
Iteration: 487; Percent complete: 12.2%; Average loss: 3.8613
Iteration: 488; Percent complete: 12.2%; Average loss: 3.9939
Iteration: 489; Percent complete: 12.2%; Average loss: 3.7486
Iteration: 490; Percent complete: 12.2%; Average loss: 3.7170
Iteration: 491; Percent complete: 12.3%; Average loss: 3.5677
Iteration: 492; Percent complete: 12.3%; Average loss: 3.6018
Iteration: 493; Percent complete: 12.3%; Average loss: 3.6524
Iteration: 494; Percent complete: 12.3%; Average loss: 3.7476
Iteration: 495; Percent complete: 12.4%; Average loss: 3.5455
Iteration: 496; Percent complete: 12.4%; Average loss: 3.3100
Iteration: 497; Percent complete: 12.4%; Average loss: 3.7155
Iteration: 498; Percent complete: 12.4%; Average loss: 3.3803
Iteration: 499; Percent complete: 12.5%; Average loss: 3.6765
Iteration: 500; Percent complete: 12.5%; Average loss: 3.7840
Iteration: 501; Percent complete: 12.5%; Average loss: 3.5825
Iteration: 502; Percent complete: 12.6%; Average loss: 3.7416
Iteration: 503; Percent complete: 12.6%; Average loss: 3.4979
Iteration: 504; Percent complete: 12.6%; Average loss: 3.7383
Iteration: 505; Percent complete: 12.6%; Average loss: 3.8051
Iteration: 506; Percent complete: 12.7%; Average loss: 3.5802
Iteration: 507; Percent complete: 12.7%; Average loss: 3.7461
Iteration: 508; Percent complete: 12.7%; Average loss: 3.5987
Iteration: 509; Percent complete: 12.7%; Average loss: 3.6375
Iteration: 510; Percent complete: 12.8%; Average loss: 3.6063
Iteration: 511; Percent complete: 12.8%; Average loss: 3.5822
Iteration: 512; Percent complete: 12.8%; Average loss: 3.8297
Iteration: 513; Percent complete: 12.8%; Average loss: 3.6389
Iteration: 514; Percent complete: 12.8%; Average loss: 3.6022
Iteration: 515; Percent complete: 12.9%; Average loss: 3.7420
Iteration: 516; Percent complete: 12.9%; Average loss: 3.7089
Iteration: 517; Percent complete: 12.9%; Average loss: 3.7100
Iteration: 518; Percent complete: 13.0%; Average loss: 3.8693
Iteration: 519; Percent complete: 13.0%; Average loss: 3.9716
Iteration: 520; Percent complete: 13.0%; Average loss: 3.4395
Iteration: 521; Percent complete: 13.0%; Average loss: 3.9406
Iteration: 522; Percent complete: 13.1%; Average loss: 3.6944
Iteration: 523; Percent complete: 13.1%; Average loss: 3.6009
Iteration: 524; Percent complete: 13.1%; Average loss: 3.8150
Iteration: 525; Percent complete: 13.1%; Average loss: 3.8529
Iteration: 526; Percent complete: 13.2%; Average loss: 3.7907
Iteration: 527; Percent complete: 13.2%; Average loss: 3.4242
Iteration: 528; Percent complete: 13.2%; Average loss: 3.4777
Iteration: 529; Percent complete: 13.2%; Average loss: 3.6243
Iteration: 530; Percent complete: 13.2%; Average loss: 3.7864
Iteration: 531; Percent complete: 13.3%; Average loss: 3.6389
Iteration: 532; Percent complete: 13.3%; Average loss: 3.9440
Iteration: 533; Percent complete: 13.3%; Average loss: 3.7467
Iteration: 534; Percent complete: 13.4%; Average loss: 3.7517
Iteration: 535; Percent complete: 13.4%; Average loss: 3.7827
Iteration: 536; Percent complete: 13.4%; Average loss: 3.8266
Iteration: 537; Percent complete: 13.4%; Average loss: 3.7861
Iteration: 538; Percent complete: 13.5%; Average loss: 3.7621
Iteration: 539; Percent complete: 13.5%; Average loss: 3.7255
Iteration: 540; Percent complete: 13.5%; Average loss: 3.9434
Iteration: 541; Percent complete: 13.5%; Average loss: 3.7698
Iteration: 542; Percent complete: 13.6%; Average loss: 3.7363
Iteration: 543; Percent complete: 13.6%; Average loss: 3.6397
Iteration: 544; Percent complete: 13.6%; Average loss: 3.5716
Iteration: 545; Percent complete: 13.6%; Average loss: 3.6455
Iteration: 546; Percent complete: 13.7%; Average loss: 3.5952
Iteration: 547; Percent complete: 13.7%; Average loss: 4.1127
Iteration: 548; Percent complete: 13.7%; Average loss: 3.9347
Iteration: 549; Percent complete: 13.7%; Average loss: 3.5551
Iteration: 550; Percent complete: 13.8%; Average loss: 3.8347
Iteration: 551; Percent complete: 13.8%; Average loss: 3.8183
Iteration: 552; Percent complete: 13.8%; Average loss: 3.7218
Iteration: 553; Percent complete: 13.8%; Average loss: 3.6554
Iteration: 554; Percent complete: 13.9%; Average loss: 3.8207
Iteration: 555; Percent complete: 13.9%; Average loss: 3.7334
Iteration: 556; Percent complete: 13.9%; Average loss: 3.9157
Iteration: 557; Percent complete: 13.9%; Average loss: 3.4294
Iteration: 558; Percent complete: 14.0%; Average loss: 3.7300
Iteration: 559; Percent complete: 14.0%; Average loss: 3.7851
Iteration: 560; Percent complete: 14.0%; Average loss: 3.9289
Iteration: 561; Percent complete: 14.0%; Average loss: 3.5502
Iteration: 562; Percent complete: 14.1%; Average loss: 3.7617
Iteration: 563; Percent complete: 14.1%; Average loss: 3.7966
Iteration: 564; Percent complete: 14.1%; Average loss: 3.5375
Iteration: 565; Percent complete: 14.1%; Average loss: 3.7642
Iteration: 566; Percent complete: 14.1%; Average loss: 3.7466
Iteration: 567; Percent complete: 14.2%; Average loss: 3.8473
Iteration: 568; Percent complete: 14.2%; Average loss: 3.5658
Iteration: 569; Percent complete: 14.2%; Average loss: 4.0620
Iteration: 570; Percent complete: 14.2%; Average loss: 3.7630
Iteration: 571; Percent complete: 14.3%; Average loss: 3.7209
Iteration: 572; Percent complete: 14.3%; Average loss: 3.5840
Iteration: 573; Percent complete: 14.3%; Average loss: 3.6462
Iteration: 574; Percent complete: 14.3%; Average loss: 3.8460
Iteration: 575; Percent complete: 14.4%; Average loss: 3.6797
Iteration: 576; Percent complete: 14.4%; Average loss: 3.7137
Iteration: 577; Percent complete: 14.4%; Average loss: 3.7471
Iteration: 578; Percent complete: 14.4%; Average loss: 3.8758
Iteration: 579; Percent complete: 14.5%; Average loss: 3.5162
Iteration: 580; Percent complete: 14.5%; Average loss: 3.6083
Iteration: 581; Percent complete: 14.5%; Average loss: 3.3724
Iteration: 582; Percent complete: 14.5%; Average loss: 3.8935
Iteration: 583; Percent complete: 14.6%; Average loss: 3.5535
Iteration: 584; Percent complete: 14.6%; Average loss: 3.4717
Iteration: 585; Percent complete: 14.6%; Average loss: 3.5653
Iteration: 586; Percent complete: 14.6%; Average loss: 3.7965
Iteration: 587; Percent complete: 14.7%; Average loss: 3.6855
Iteration: 588; Percent complete: 14.7%; Average loss: 3.7323
Iteration: 589; Percent complete: 14.7%; Average loss: 3.7297
Iteration: 590; Percent complete: 14.8%; Average loss: 3.7565
Iteration: 591; Percent complete: 14.8%; Average loss: 3.8498
Iteration: 592; Percent complete: 14.8%; Average loss: 3.6411
Iteration: 593; Percent complete: 14.8%; Average loss: 3.8644
Iteration: 594; Percent complete: 14.8%; Average loss: 3.7144
Iteration: 595; Percent complete: 14.9%; Average loss: 3.7597
Iteration: 596; Percent complete: 14.9%; Average loss: 3.6473
Iteration: 597; Percent complete: 14.9%; Average loss: 3.7519
Iteration: 598; Percent complete: 14.9%; Average loss: 3.9008
Iteration: 599; Percent complete: 15.0%; Average loss: 3.6962
Iteration: 600; Percent complete: 15.0%; Average loss: 3.7748
Iteration: 601; Percent complete: 15.0%; Average loss: 3.5013
Iteration: 602; Percent complete: 15.0%; Average loss: 3.4979
Iteration: 603; Percent complete: 15.1%; Average loss: 3.8440
Iteration: 604; Percent complete: 15.1%; Average loss: 3.8308
Iteration: 605; Percent complete: 15.1%; Average loss: 3.6219
Iteration: 606; Percent complete: 15.2%; Average loss: 3.7070
Iteration: 607; Percent complete: 15.2%; Average loss: 3.7257
Iteration: 608; Percent complete: 15.2%; Average loss: 3.9426
Iteration: 609; Percent complete: 15.2%; Average loss: 3.6601
Iteration: 610; Percent complete: 15.2%; Average loss: 3.7292
Iteration: 611; Percent complete: 15.3%; Average loss: 3.8293
Iteration: 612; Percent complete: 15.3%; Average loss: 3.6272
Iteration: 613; Percent complete: 15.3%; Average loss: 3.4901
Iteration: 614; Percent complete: 15.3%; Average loss: 3.4348
Iteration: 615; Percent complete: 15.4%; Average loss: 3.8562
Iteration: 616; Percent complete: 15.4%; Average loss: 3.7042
Iteration: 617; Percent complete: 15.4%; Average loss: 3.6766
Iteration: 618; Percent complete: 15.4%; Average loss: 3.6740
Iteration: 619; Percent complete: 15.5%; Average loss: 3.6065
Iteration: 620; Percent complete: 15.5%; Average loss: 3.7841
Iteration: 621; Percent complete: 15.5%; Average loss: 3.6786
Iteration: 622; Percent complete: 15.6%; Average loss: 3.7897
Iteration: 623; Percent complete: 15.6%; Average loss: 3.5297
Iteration: 624; Percent complete: 15.6%; Average loss: 3.5000
Iteration: 625; Percent complete: 15.6%; Average loss: 3.6323
Iteration: 626; Percent complete: 15.7%; Average loss: 3.4960
Iteration: 627; Percent complete: 15.7%; Average loss: 3.6467
Iteration: 628; Percent complete: 15.7%; Average loss: 3.6161
Iteration: 629; Percent complete: 15.7%; Average loss: 3.8295
Iteration: 630; Percent complete: 15.8%; Average loss: 3.7190
Iteration: 631; Percent complete: 15.8%; Average loss: 3.5861
Iteration: 632; Percent complete: 15.8%; Average loss: 3.8733
Iteration: 633; Percent complete: 15.8%; Average loss: 3.6253
Iteration: 634; Percent complete: 15.8%; Average loss: 3.7615
Iteration: 635; Percent complete: 15.9%; Average loss: 3.6834
Iteration: 636; Percent complete: 15.9%; Average loss: 3.4502
Iteration: 637; Percent complete: 15.9%; Average loss: 3.6878
Iteration: 638; Percent complete: 16.0%; Average loss: 3.7197
Iteration: 639; Percent complete: 16.0%; Average loss: 3.6825
Iteration: 640; Percent complete: 16.0%; Average loss: 3.6728
Iteration: 641; Percent complete: 16.0%; Average loss: 3.7353
Iteration: 642; Percent complete: 16.1%; Average loss: 3.4899
Iteration: 643; Percent complete: 16.1%; Average loss: 3.7981
Iteration: 644; Percent complete: 16.1%; Average loss: 3.5941
Iteration: 645; Percent complete: 16.1%; Average loss: 3.6594
Iteration: 646; Percent complete: 16.2%; Average loss: 3.6010
Iteration: 647; Percent complete: 16.2%; Average loss: 3.6074
Iteration: 648; Percent complete: 16.2%; Average loss: 3.6377
Iteration: 649; Percent complete: 16.2%; Average loss: 3.5541
Iteration: 650; Percent complete: 16.2%; Average loss: 3.8281
Iteration: 651; Percent complete: 16.3%; Average loss: 3.5037
Iteration: 652; Percent complete: 16.3%; Average loss: 3.8609
Iteration: 653; Percent complete: 16.3%; Average loss: 3.7004
Iteration: 654; Percent complete: 16.4%; Average loss: 3.4432
Iteration: 655; Percent complete: 16.4%; Average loss: 3.7212
Iteration: 656; Percent complete: 16.4%; Average loss: 3.8125
Iteration: 657; Percent complete: 16.4%; Average loss: 3.5342
Iteration: 658; Percent complete: 16.4%; Average loss: 3.6262
Iteration: 659; Percent complete: 16.5%; Average loss: 3.4360
Iteration: 660; Percent complete: 16.5%; Average loss: 3.7206
Iteration: 661; Percent complete: 16.5%; Average loss: 3.5054
Iteration: 662; Percent complete: 16.6%; Average loss: 3.5949
Iteration: 663; Percent complete: 16.6%; Average loss: 3.7748
Iteration: 664; Percent complete: 16.6%; Average loss: 3.7576
Iteration: 665; Percent complete: 16.6%; Average loss: 3.6313
Iteration: 666; Percent complete: 16.7%; Average loss: 3.4228
Iteration: 667; Percent complete: 16.7%; Average loss: 3.6645
Iteration: 668; Percent complete: 16.7%; Average loss: 3.6533
Iteration: 669; Percent complete: 16.7%; Average loss: 3.9879
Iteration: 670; Percent complete: 16.8%; Average loss: 3.9070
Iteration: 671; Percent complete: 16.8%; Average loss: 3.5616
Iteration: 672; Percent complete: 16.8%; Average loss: 3.3708
Iteration: 673; Percent complete: 16.8%; Average loss: 3.5844
Iteration: 674; Percent complete: 16.9%; Average loss: 3.7067
Iteration: 675; Percent complete: 16.9%; Average loss: 3.6995
Iteration: 676; Percent complete: 16.9%; Average loss: 3.3684
Iteration: 677; Percent complete: 16.9%; Average loss: 3.8035
Iteration: 678; Percent complete: 17.0%; Average loss: 3.6452
Iteration: 679; Percent complete: 17.0%; Average loss: 3.6201
Iteration: 680; Percent complete: 17.0%; Average loss: 3.6294
Iteration: 681; Percent complete: 17.0%; Average loss: 3.7470
Iteration: 682; Percent complete: 17.1%; Average loss: 3.7799
Iteration: 683; Percent complete: 17.1%; Average loss: 3.7169
Iteration: 684; Percent complete: 17.1%; Average loss: 3.5534
Iteration: 685; Percent complete: 17.1%; Average loss: 3.7713
Iteration: 686; Percent complete: 17.2%; Average loss: 3.6246
Iteration: 687; Percent complete: 17.2%; Average loss: 3.9204
Iteration: 688; Percent complete: 17.2%; Average loss: 3.4931
Iteration: 689; Percent complete: 17.2%; Average loss: 3.5115
Iteration: 690; Percent complete: 17.2%; Average loss: 3.6194
Iteration: 691; Percent complete: 17.3%; Average loss: 3.8483
Iteration: 692; Percent complete: 17.3%; Average loss: 3.6509
Iteration: 693; Percent complete: 17.3%; Average loss: 3.2121
Iteration: 694; Percent complete: 17.3%; Average loss: 3.6298
Iteration: 695; Percent complete: 17.4%; Average loss: 3.5122
Iteration: 696; Percent complete: 17.4%; Average loss: 3.3828
Iteration: 697; Percent complete: 17.4%; Average loss: 3.7353
Iteration: 698; Percent complete: 17.4%; Average loss: 3.7154
Iteration: 699; Percent complete: 17.5%; Average loss: 3.5928
Iteration: 700; Percent complete: 17.5%; Average loss: 3.6887
Iteration: 701; Percent complete: 17.5%; Average loss: 3.7439
Iteration: 702; Percent complete: 17.5%; Average loss: 3.6827
Iteration: 703; Percent complete: 17.6%; Average loss: 3.6491
Iteration: 704; Percent complete: 17.6%; Average loss: 3.7908
Iteration: 705; Percent complete: 17.6%; Average loss: 3.9208
Iteration: 706; Percent complete: 17.6%; Average loss: 3.7122
Iteration: 707; Percent complete: 17.7%; Average loss: 3.8741
Iteration: 708; Percent complete: 17.7%; Average loss: 3.7890
Iteration: 709; Percent complete: 17.7%; Average loss: 3.5269
Iteration: 710; Percent complete: 17.8%; Average loss: 3.7166
Iteration: 711; Percent complete: 17.8%; Average loss: 3.8768
Iteration: 712; Percent complete: 17.8%; Average loss: 3.6189
Iteration: 713; Percent complete: 17.8%; Average loss: 3.6853
Iteration: 714; Percent complete: 17.8%; Average loss: 3.4621
Iteration: 715; Percent complete: 17.9%; Average loss: 3.3703
Iteration: 716; Percent complete: 17.9%; Average loss: 3.5522
Iteration: 717; Percent complete: 17.9%; Average loss: 3.5535
Iteration: 718; Percent complete: 17.9%; Average loss: 3.4211
Iteration: 719; Percent complete: 18.0%; Average loss: 3.4787
Iteration: 720; Percent complete: 18.0%; Average loss: 3.8258
Iteration: 721; Percent complete: 18.0%; Average loss: 3.7279
Iteration: 722; Percent complete: 18.1%; Average loss: 3.8598
Iteration: 723; Percent complete: 18.1%; Average loss: 3.7002
Iteration: 724; Percent complete: 18.1%; Average loss: 3.4997
Iteration: 725; Percent complete: 18.1%; Average loss: 3.5401
Iteration: 726; Percent complete: 18.1%; Average loss: 3.7087
Iteration: 727; Percent complete: 18.2%; Average loss: 3.7712
Iteration: 728; Percent complete: 18.2%; Average loss: 3.7017
Iteration: 729; Percent complete: 18.2%; Average loss: 3.6569
Iteration: 730; Percent complete: 18.2%; Average loss: 3.6311
Iteration: 731; Percent complete: 18.3%; Average loss: 3.7112
Iteration: 732; Percent complete: 18.3%; Average loss: 3.5577
Iteration: 733; Percent complete: 18.3%; Average loss: 3.4941
Iteration: 734; Percent complete: 18.4%; Average loss: 3.6592
Iteration: 735; Percent complete: 18.4%; Average loss: 3.2821
Iteration: 736; Percent complete: 18.4%; Average loss: 3.5046
Iteration: 737; Percent complete: 18.4%; Average loss: 3.5760
Iteration: 738; Percent complete: 18.4%; Average loss: 3.4460
Iteration: 739; Percent complete: 18.5%; Average loss: 3.6387
Iteration: 740; Percent complete: 18.5%; Average loss: 3.8389
Iteration: 741; Percent complete: 18.5%; Average loss: 3.4288
Iteration: 742; Percent complete: 18.6%; Average loss: 3.5015
Iteration: 743; Percent complete: 18.6%; Average loss: 3.8387
Iteration: 744; Percent complete: 18.6%; Average loss: 3.8666
Iteration: 745; Percent complete: 18.6%; Average loss: 3.7168
Iteration: 746; Percent complete: 18.6%; Average loss: 3.8497
Iteration: 747; Percent complete: 18.7%; Average loss: 3.6639
Iteration: 748; Percent complete: 18.7%; Average loss: 3.6281
Iteration: 749; Percent complete: 18.7%; Average loss: 3.4592
Iteration: 750; Percent complete: 18.8%; Average loss: 3.8239
Iteration: 751; Percent complete: 18.8%; Average loss: 3.5735
Iteration: 752; Percent complete: 18.8%; Average loss: 3.4827
Iteration: 753; Percent complete: 18.8%; Average loss: 3.3892
Iteration: 754; Percent complete: 18.9%; Average loss: 3.6014
Iteration: 755; Percent complete: 18.9%; Average loss: 3.3736
Iteration: 756; Percent complete: 18.9%; Average loss: 3.7129
Iteration: 757; Percent complete: 18.9%; Average loss: 3.6600
Iteration: 758; Percent complete: 18.9%; Average loss: 3.6118
Iteration: 759; Percent complete: 19.0%; Average loss: 3.5966
Iteration: 760; Percent complete: 19.0%; Average loss: 3.3497
Iteration: 761; Percent complete: 19.0%; Average loss: 3.5283
Iteration: 762; Percent complete: 19.1%; Average loss: 3.5033
Iteration: 763; Percent complete: 19.1%; Average loss: 3.5850
Iteration: 764; Percent complete: 19.1%; Average loss: 3.5969
Iteration: 765; Percent complete: 19.1%; Average loss: 3.3180
Iteration: 766; Percent complete: 19.1%; Average loss: 3.7355
Iteration: 767; Percent complete: 19.2%; Average loss: 3.4935
Iteration: 768; Percent complete: 19.2%; Average loss: 3.5464
Iteration: 769; Percent complete: 19.2%; Average loss: 3.6936
Iteration: 770; Percent complete: 19.2%; Average loss: 3.6959
Iteration: 771; Percent complete: 19.3%; Average loss: 3.8836
Iteration: 772; Percent complete: 19.3%; Average loss: 3.6989
Iteration: 773; Percent complete: 19.3%; Average loss: 3.5607
Iteration: 774; Percent complete: 19.4%; Average loss: 3.2085
Iteration: 775; Percent complete: 19.4%; Average loss: 3.3623
Iteration: 776; Percent complete: 19.4%; Average loss: 3.6200
Iteration: 777; Percent complete: 19.4%; Average loss: 3.6694
Iteration: 778; Percent complete: 19.4%; Average loss: 3.2367
Iteration: 779; Percent complete: 19.5%; Average loss: 3.5981
Iteration: 780; Percent complete: 19.5%; Average loss: 3.6769
Iteration: 781; Percent complete: 19.5%; Average loss: 3.3544
Iteration: 782; Percent complete: 19.6%; Average loss: 3.7108
Iteration: 783; Percent complete: 19.6%; Average loss: 3.5326
Iteration: 784; Percent complete: 19.6%; Average loss: 3.6747
Iteration: 785; Percent complete: 19.6%; Average loss: 3.4389
Iteration: 786; Percent complete: 19.7%; Average loss: 3.6516
Iteration: 787; Percent complete: 19.7%; Average loss: 3.6646
Iteration: 788; Percent complete: 19.7%; Average loss: 3.6295
Iteration: 789; Percent complete: 19.7%; Average loss: 3.5049
Iteration: 790; Percent complete: 19.8%; Average loss: 3.6889
Iteration: 791; Percent complete: 19.8%; Average loss: 3.6775
Iteration: 792; Percent complete: 19.8%; Average loss: 3.3781
Iteration: 793; Percent complete: 19.8%; Average loss: 3.6787
Iteration: 794; Percent complete: 19.9%; Average loss: 3.3562
Iteration: 795; Percent complete: 19.9%; Average loss: 3.3943
Iteration: 796; Percent complete: 19.9%; Average loss: 3.5726
Iteration: 797; Percent complete: 19.9%; Average loss: 3.4574
Iteration: 798; Percent complete: 20.0%; Average loss: 3.3356
Iteration: 799; Percent complete: 20.0%; Average loss: 3.6607
Iteration: 800; Percent complete: 20.0%; Average loss: 3.8334
Iteration: 801; Percent complete: 20.0%; Average loss: 3.5785
Iteration: 802; Percent complete: 20.1%; Average loss: 3.4133
Iteration: 803; Percent complete: 20.1%; Average loss: 3.6679
Iteration: 804; Percent complete: 20.1%; Average loss: 3.4462
Iteration: 805; Percent complete: 20.1%; Average loss: 3.3887
Iteration: 806; Percent complete: 20.2%; Average loss: 3.5271
Iteration: 807; Percent complete: 20.2%; Average loss: 3.6246
Iteration: 808; Percent complete: 20.2%; Average loss: 3.7525
Iteration: 809; Percent complete: 20.2%; Average loss: 3.6733
Iteration: 810; Percent complete: 20.2%; Average loss: 3.6084
Iteration: 811; Percent complete: 20.3%; Average loss: 3.3527
Iteration: 812; Percent complete: 20.3%; Average loss: 3.8462
Iteration: 813; Percent complete: 20.3%; Average loss: 3.4928
Iteration: 814; Percent complete: 20.3%; Average loss: 3.5841
Iteration: 815; Percent complete: 20.4%; Average loss: 3.5688
Iteration: 816; Percent complete: 20.4%; Average loss: 3.6012
Iteration: 817; Percent complete: 20.4%; Average loss: 3.7582
Iteration: 818; Percent complete: 20.4%; Average loss: 3.4834
Iteration: 819; Percent complete: 20.5%; Average loss: 3.6623
Iteration: 820; Percent complete: 20.5%; Average loss: 3.7548
Iteration: 821; Percent complete: 20.5%; Average loss: 3.5472
Iteration: 822; Percent complete: 20.5%; Average loss: 3.4940
Iteration: 823; Percent complete: 20.6%; Average loss: 3.4941
Iteration: 824; Percent complete: 20.6%; Average loss: 3.5709
Iteration: 825; Percent complete: 20.6%; Average loss: 3.4893
Iteration: 826; Percent complete: 20.6%; Average loss: 3.5351
Iteration: 827; Percent complete: 20.7%; Average loss: 3.5547
Iteration: 828; Percent complete: 20.7%; Average loss: 3.4428
Iteration: 829; Percent complete: 20.7%; Average loss: 3.4922
Iteration: 830; Percent complete: 20.8%; Average loss: 3.6954
Iteration: 831; Percent complete: 20.8%; Average loss: 3.5248
Iteration: 832; Percent complete: 20.8%; Average loss: 3.8163
Iteration: 833; Percent complete: 20.8%; Average loss: 3.6497
Iteration: 834; Percent complete: 20.8%; Average loss: 3.1286
Iteration: 835; Percent complete: 20.9%; Average loss: 3.4098
Iteration: 836; Percent complete: 20.9%; Average loss: 3.6017
Iteration: 837; Percent complete: 20.9%; Average loss: 3.5443
Iteration: 838; Percent complete: 20.9%; Average loss: 3.9100
Iteration: 839; Percent complete: 21.0%; Average loss: 3.7077
Iteration: 840; Percent complete: 21.0%; Average loss: 3.6148
Iteration: 841; Percent complete: 21.0%; Average loss: 3.5786
Iteration: 842; Percent complete: 21.1%; Average loss: 3.6082
Iteration: 843; Percent complete: 21.1%; Average loss: 3.4137
Iteration: 844; Percent complete: 21.1%; Average loss: 3.5490
Iteration: 845; Percent complete: 21.1%; Average loss: 3.8022
Iteration: 846; Percent complete: 21.1%; Average loss: 3.6321
Iteration: 847; Percent complete: 21.2%; Average loss: 3.5281
Iteration: 848; Percent complete: 21.2%; Average loss: 3.6467
Iteration: 849; Percent complete: 21.2%; Average loss: 3.4736
Iteration: 850; Percent complete: 21.2%; Average loss: 3.6899
Iteration: 851; Percent complete: 21.3%; Average loss: 3.6473
Iteration: 852; Percent complete: 21.3%; Average loss: 3.5942
Iteration: 853; Percent complete: 21.3%; Average loss: 3.0458
Iteration: 854; Percent complete: 21.3%; Average loss: 3.6250
Iteration: 855; Percent complete: 21.4%; Average loss: 3.4576
Iteration: 856; Percent complete: 21.4%; Average loss: 3.5288
Iteration: 857; Percent complete: 21.4%; Average loss: 3.3444
Iteration: 858; Percent complete: 21.4%; Average loss: 3.3028
Iteration: 859; Percent complete: 21.5%; Average loss: 3.3853
Iteration: 860; Percent complete: 21.5%; Average loss: 3.6013
Iteration: 861; Percent complete: 21.5%; Average loss: 3.5910
Iteration: 862; Percent complete: 21.6%; Average loss: 3.6720
Iteration: 863; Percent complete: 21.6%; Average loss: 3.4878
Iteration: 864; Percent complete: 21.6%; Average loss: 3.6331
Iteration: 865; Percent complete: 21.6%; Average loss: 3.5183
Iteration: 866; Percent complete: 21.6%; Average loss: 3.6723
Iteration: 867; Percent complete: 21.7%; Average loss: 3.5234
Iteration: 868; Percent complete: 21.7%; Average loss: 3.3686
Iteration: 869; Percent complete: 21.7%; Average loss: 3.2611
Iteration: 870; Percent complete: 21.8%; Average loss: 3.4836
Iteration: 871; Percent complete: 21.8%; Average loss: 3.7200
Iteration: 872; Percent complete: 21.8%; Average loss: 3.2996
Iteration: 873; Percent complete: 21.8%; Average loss: 3.3943
Iteration: 874; Percent complete: 21.9%; Average loss: 3.3417
Iteration: 875; Percent complete: 21.9%; Average loss: 3.6824
Iteration: 876; Percent complete: 21.9%; Average loss: 3.6099
Iteration: 877; Percent complete: 21.9%; Average loss: 3.5451
Iteration: 878; Percent complete: 21.9%; Average loss: 3.7369
Iteration: 879; Percent complete: 22.0%; Average loss: 3.6101
Iteration: 880; Percent complete: 22.0%; Average loss: 3.6655
Iteration: 881; Percent complete: 22.0%; Average loss: 3.1963
Iteration: 882; Percent complete: 22.1%; Average loss: 3.5561
Iteration: 883; Percent complete: 22.1%; Average loss: 3.4652
Iteration: 884; Percent complete: 22.1%; Average loss: 3.4632
Iteration: 885; Percent complete: 22.1%; Average loss: 3.5470
Iteration: 886; Percent complete: 22.1%; Average loss: 3.7384
Iteration: 887; Percent complete: 22.2%; Average loss: 3.5223
Iteration: 888; Percent complete: 22.2%; Average loss: 3.3356
Iteration: 889; Percent complete: 22.2%; Average loss: 3.5370
Iteration: 890; Percent complete: 22.2%; Average loss: 3.5550
Iteration: 891; Percent complete: 22.3%; Average loss: 3.5711
Iteration: 892; Percent complete: 22.3%; Average loss: 3.6978
Iteration: 893; Percent complete: 22.3%; Average loss: 3.4167
Iteration: 894; Percent complete: 22.4%; Average loss: 3.7232
Iteration: 895; Percent complete: 22.4%; Average loss: 3.3478
Iteration: 896; Percent complete: 22.4%; Average loss: 3.5054
Iteration: 897; Percent complete: 22.4%; Average loss: 3.6088
Iteration: 898; Percent complete: 22.4%; Average loss: 3.6403
Iteration: 899; Percent complete: 22.5%; Average loss: 3.3667
Iteration: 900; Percent complete: 22.5%; Average loss: 3.4164
Iteration: 901; Percent complete: 22.5%; Average loss: 3.4610
Iteration: 902; Percent complete: 22.6%; Average loss: 3.4679
Iteration: 903; Percent complete: 22.6%; Average loss: 3.6519
Iteration: 904; Percent complete: 22.6%; Average loss: 3.5090
Iteration: 905; Percent complete: 22.6%; Average loss: 3.4473
Iteration: 906; Percent complete: 22.7%; Average loss: 3.3250
Iteration: 907; Percent complete: 22.7%; Average loss: 3.6498
Iteration: 908; Percent complete: 22.7%; Average loss: 3.2230
Iteration: 909; Percent complete: 22.7%; Average loss: 3.5356
Iteration: 910; Percent complete: 22.8%; Average loss: 3.4665
Iteration: 911; Percent complete: 22.8%; Average loss: 3.4860
Iteration: 912; Percent complete: 22.8%; Average loss: 3.7438
Iteration: 913; Percent complete: 22.8%; Average loss: 3.4674
Iteration: 914; Percent complete: 22.9%; Average loss: 3.4043
Iteration: 915; Percent complete: 22.9%; Average loss: 3.4829
Iteration: 916; Percent complete: 22.9%; Average loss: 3.5983
Iteration: 917; Percent complete: 22.9%; Average loss: 3.4591
Iteration: 918; Percent complete: 22.9%; Average loss: 3.5801
Iteration: 919; Percent complete: 23.0%; Average loss: 3.5906
Iteration: 920; Percent complete: 23.0%; Average loss: 3.1423
Iteration: 921; Percent complete: 23.0%; Average loss: 3.6860
Iteration: 922; Percent complete: 23.1%; Average loss: 3.6178
Iteration: 923; Percent complete: 23.1%; Average loss: 3.5241
Iteration: 924; Percent complete: 23.1%; Average loss: 3.4102
Iteration: 925; Percent complete: 23.1%; Average loss: 3.5647
Iteration: 926; Percent complete: 23.2%; Average loss: 3.3710
Iteration: 927; Percent complete: 23.2%; Average loss: 3.5232
Iteration: 928; Percent complete: 23.2%; Average loss: 3.3465
Iteration: 929; Percent complete: 23.2%; Average loss: 3.3468
Iteration: 930; Percent complete: 23.2%; Average loss: 4.0741
Iteration: 931; Percent complete: 23.3%; Average loss: 3.5319
Iteration: 932; Percent complete: 23.3%; Average loss: 3.4578
Iteration: 933; Percent complete: 23.3%; Average loss: 3.5727
Iteration: 934; Percent complete: 23.4%; Average loss: 3.5346
Iteration: 935; Percent complete: 23.4%; Average loss: 3.7404
Iteration: 936; Percent complete: 23.4%; Average loss: 3.5935
Iteration: 937; Percent complete: 23.4%; Average loss: 3.5548
Iteration: 938; Percent complete: 23.4%; Average loss: 3.3577
Iteration: 939; Percent complete: 23.5%; Average loss: 3.5772
Iteration: 940; Percent complete: 23.5%; Average loss: 3.6734
Iteration: 941; Percent complete: 23.5%; Average loss: 3.6165
Iteration: 942; Percent complete: 23.5%; Average loss: 3.4662
Iteration: 943; Percent complete: 23.6%; Average loss: 3.6083
Iteration: 944; Percent complete: 23.6%; Average loss: 3.7353
Iteration: 945; Percent complete: 23.6%; Average loss: 3.5752
Iteration: 946; Percent complete: 23.6%; Average loss: 3.4250
Iteration: 947; Percent complete: 23.7%; Average loss: 3.4722
Iteration: 948; Percent complete: 23.7%; Average loss: 3.2792
Iteration: 949; Percent complete: 23.7%; Average loss: 3.5276
Iteration: 950; Percent complete: 23.8%; Average loss: 3.7380
Iteration: 951; Percent complete: 23.8%; Average loss: 3.4541
Iteration: 952; Percent complete: 23.8%; Average loss: 3.5738
Iteration: 953; Percent complete: 23.8%; Average loss: 3.2678
Iteration: 954; Percent complete: 23.8%; Average loss: 3.5415
Iteration: 955; Percent complete: 23.9%; Average loss: 3.6775
Iteration: 956; Percent complete: 23.9%; Average loss: 3.7545
Iteration: 957; Percent complete: 23.9%; Average loss: 3.8028
Iteration: 958; Percent complete: 23.9%; Average loss: 3.3421
Iteration: 959; Percent complete: 24.0%; Average loss: 3.5865
Iteration: 960; Percent complete: 24.0%; Average loss: 3.5039
Iteration: 961; Percent complete: 24.0%; Average loss: 3.5901
Iteration: 962; Percent complete: 24.1%; Average loss: 3.7128
Iteration: 963; Percent complete: 24.1%; Average loss: 3.3234
Iteration: 964; Percent complete: 24.1%; Average loss: 3.3558
Iteration: 965; Percent complete: 24.1%; Average loss: 3.4685
Iteration: 966; Percent complete: 24.1%; Average loss: 3.8126
Iteration: 967; Percent complete: 24.2%; Average loss: 3.7549
Iteration: 968; Percent complete: 24.2%; Average loss: 3.4203
Iteration: 969; Percent complete: 24.2%; Average loss: 3.2600
Iteration: 970; Percent complete: 24.2%; Average loss: 3.6519
Iteration: 971; Percent complete: 24.3%; Average loss: 3.3573
Iteration: 972; Percent complete: 24.3%; Average loss: 3.3847
Iteration: 973; Percent complete: 24.3%; Average loss: 3.4446
Iteration: 974; Percent complete: 24.3%; Average loss: 3.6296
Iteration: 975; Percent complete: 24.4%; Average loss: 3.4352
Iteration: 976; Percent complete: 24.4%; Average loss: 3.3093
Iteration: 977; Percent complete: 24.4%; Average loss: 3.4408
Iteration: 978; Percent complete: 24.4%; Average loss: 3.3003
Iteration: 979; Percent complete: 24.5%; Average loss: 3.7192
Iteration: 980; Percent complete: 24.5%; Average loss: 3.4046
Iteration: 981; Percent complete: 24.5%; Average loss: 3.3373
Iteration: 982; Percent complete: 24.6%; Average loss: 3.3913
Iteration: 983; Percent complete: 24.6%; Average loss: 3.5099
Iteration: 984; Percent complete: 24.6%; Average loss: 3.3531
Iteration: 985; Percent complete: 24.6%; Average loss: 3.4003
Iteration: 986; Percent complete: 24.6%; Average loss: 3.6262
Iteration: 987; Percent complete: 24.7%; Average loss: 3.4194
Iteration: 988; Percent complete: 24.7%; Average loss: 3.4124
Iteration: 989; Percent complete: 24.7%; Average loss: 3.2752
Iteration: 990; Percent complete: 24.8%; Average loss: 3.5236
Iteration: 991; Percent complete: 24.8%; Average loss: 3.5218
Iteration: 992; Percent complete: 24.8%; Average loss: 3.3656
Iteration: 993; Percent complete: 24.8%; Average loss: 3.2548
Iteration: 994; Percent complete: 24.9%; Average loss: 3.3314
Iteration: 995; Percent complete: 24.9%; Average loss: 3.2601
Iteration: 996; Percent complete: 24.9%; Average loss: 3.3704
Iteration: 997; Percent complete: 24.9%; Average loss: 3.1037
Iteration: 998; Percent complete: 24.9%; Average loss: 3.6460
Iteration: 999; Percent complete: 25.0%; Average loss: 3.3910
Iteration: 1000; Percent complete: 25.0%; Average loss: 3.3860
Iteration: 1001; Percent complete: 25.0%; Average loss: 3.3120
Iteration: 1002; Percent complete: 25.1%; Average loss: 3.4006
Iteration: 1003; Percent complete: 25.1%; Average loss: 3.3191
Iteration: 1004; Percent complete: 25.1%; Average loss: 3.4010
Iteration: 1005; Percent complete: 25.1%; Average loss: 3.6444
Iteration: 1006; Percent complete: 25.1%; Average loss: 3.3738
Iteration: 1007; Percent complete: 25.2%; Average loss: 3.4097
Iteration: 1008; Percent complete: 25.2%; Average loss: 3.5270
Iteration: 1009; Percent complete: 25.2%; Average loss: 3.4970
Iteration: 1010; Percent complete: 25.2%; Average loss: 3.8054
Iteration: 1011; Percent complete: 25.3%; Average loss: 3.4299
Iteration: 1012; Percent complete: 25.3%; Average loss: 3.3510
Iteration: 1013; Percent complete: 25.3%; Average loss: 3.4331
Iteration: 1014; Percent complete: 25.4%; Average loss: 3.3196
Iteration: 1015; Percent complete: 25.4%; Average loss: 3.5267
Iteration: 1016; Percent complete: 25.4%; Average loss: 3.7272
Iteration: 1017; Percent complete: 25.4%; Average loss: 3.4307
Iteration: 1018; Percent complete: 25.4%; Average loss: 3.6493
Iteration: 1019; Percent complete: 25.5%; Average loss: 3.3831
Iteration: 1020; Percent complete: 25.5%; Average loss: 3.5921
Iteration: 1021; Percent complete: 25.5%; Average loss: 3.4720
Iteration: 1022; Percent complete: 25.6%; Average loss: 3.4842
Iteration: 1023; Percent complete: 25.6%; Average loss: 3.3470
Iteration: 1024; Percent complete: 25.6%; Average loss: 3.2266
Iteration: 1025; Percent complete: 25.6%; Average loss: 3.5982
Iteration: 1026; Percent complete: 25.7%; Average loss: 3.5302
Iteration: 1027; Percent complete: 25.7%; Average loss: 3.4190
Iteration: 1028; Percent complete: 25.7%; Average loss: 3.4953
Iteration: 1029; Percent complete: 25.7%; Average loss: 3.3622
Iteration: 1030; Percent complete: 25.8%; Average loss: 3.5187
Iteration: 1031; Percent complete: 25.8%; Average loss: 3.2936
Iteration: 1032; Percent complete: 25.8%; Average loss: 3.4618
Iteration: 1033; Percent complete: 25.8%; Average loss: 3.6709
Iteration: 1034; Percent complete: 25.9%; Average loss: 3.4801
Iteration: 1035; Percent complete: 25.9%; Average loss: 3.6403
Iteration: 1036; Percent complete: 25.9%; Average loss: 3.7384
Iteration: 1037; Percent complete: 25.9%; Average loss: 3.3259
Iteration: 1038; Percent complete: 25.9%; Average loss: 3.2971
Iteration: 1039; Percent complete: 26.0%; Average loss: 3.3296
Iteration: 1040; Percent complete: 26.0%; Average loss: 3.6129
Iteration: 1041; Percent complete: 26.0%; Average loss: 3.2204
Iteration: 1042; Percent complete: 26.1%; Average loss: 3.2848
Iteration: 1043; Percent complete: 26.1%; Average loss: 3.1348
Iteration: 1044; Percent complete: 26.1%; Average loss: 3.7064
Iteration: 1045; Percent complete: 26.1%; Average loss: 3.2556
Iteration: 1046; Percent complete: 26.2%; Average loss: 3.3845
Iteration: 1047; Percent complete: 26.2%; Average loss: 3.7343
Iteration: 1048; Percent complete: 26.2%; Average loss: 3.7362
Iteration: 1049; Percent complete: 26.2%; Average loss: 3.2930
Iteration: 1050; Percent complete: 26.2%; Average loss: 3.5691
Iteration: 1051; Percent complete: 26.3%; Average loss: 3.2159
Iteration: 1052; Percent complete: 26.3%; Average loss: 3.7303
Iteration: 1053; Percent complete: 26.3%; Average loss: 3.3434
Iteration: 1054; Percent complete: 26.4%; Average loss: 3.3097
Iteration: 1055; Percent complete: 26.4%; Average loss: 3.5407
Iteration: 1056; Percent complete: 26.4%; Average loss: 3.6466
Iteration: 1057; Percent complete: 26.4%; Average loss: 3.4905
Iteration: 1058; Percent complete: 26.5%; Average loss: 3.2942
Iteration: 1059; Percent complete: 26.5%; Average loss: 3.7504
Iteration: 1060; Percent complete: 26.5%; Average loss: 3.3106
Iteration: 1061; Percent complete: 26.5%; Average loss: 3.1838
Iteration: 1062; Percent complete: 26.6%; Average loss: 3.4936
Iteration: 1063; Percent complete: 26.6%; Average loss: 3.3800
Iteration: 1064; Percent complete: 26.6%; Average loss: 3.5749
Iteration: 1065; Percent complete: 26.6%; Average loss: 3.5697
Iteration: 1066; Percent complete: 26.7%; Average loss: 3.4493
Iteration: 1067; Percent complete: 26.7%; Average loss: 3.6583
Iteration: 1068; Percent complete: 26.7%; Average loss: 3.5308
Iteration: 1069; Percent complete: 26.7%; Average loss: 3.6733
Iteration: 1070; Percent complete: 26.8%; Average loss: 3.5867
Iteration: 1071; Percent complete: 26.8%; Average loss: 3.2709
Iteration: 1072; Percent complete: 26.8%; Average loss: 3.2272
Iteration: 1073; Percent complete: 26.8%; Average loss: 3.5043
Iteration: 1074; Percent complete: 26.9%; Average loss: 3.1859
Iteration: 1075; Percent complete: 26.9%; Average loss: 3.2793
Iteration: 1076; Percent complete: 26.9%; Average loss: 3.4532
Iteration: 1077; Percent complete: 26.9%; Average loss: 3.4606
Iteration: 1078; Percent complete: 27.0%; Average loss: 3.6209
Iteration: 1079; Percent complete: 27.0%; Average loss: 3.3338
Iteration: 1080; Percent complete: 27.0%; Average loss: 3.6304
Iteration: 1081; Percent complete: 27.0%; Average loss: 3.1552
Iteration: 1082; Percent complete: 27.1%; Average loss: 3.3275
Iteration: 1083; Percent complete: 27.1%; Average loss: 3.6953
Iteration: 1084; Percent complete: 27.1%; Average loss: 3.5506
Iteration: 1085; Percent complete: 27.1%; Average loss: 3.5541
Iteration: 1086; Percent complete: 27.2%; Average loss: 3.4678
Iteration: 1087; Percent complete: 27.2%; Average loss: 3.4721
Iteration: 1088; Percent complete: 27.2%; Average loss: 3.3802
Iteration: 1089; Percent complete: 27.2%; Average loss: 3.6604
Iteration: 1090; Percent complete: 27.3%; Average loss: 3.5477
Iteration: 1091; Percent complete: 27.3%; Average loss: 3.7923
Iteration: 1092; Percent complete: 27.3%; Average loss: 3.4458
Iteration: 1093; Percent complete: 27.3%; Average loss: 3.4334
Iteration: 1094; Percent complete: 27.4%; Average loss: 3.3853
Iteration: 1095; Percent complete: 27.4%; Average loss: 3.3659
Iteration: 1096; Percent complete: 27.4%; Average loss: 3.5423
Iteration: 1097; Percent complete: 27.4%; Average loss: 3.6044
Iteration: 1098; Percent complete: 27.5%; Average loss: 3.4327
Iteration: 1099; Percent complete: 27.5%; Average loss: 3.4840
Iteration: 1100; Percent complete: 27.5%; Average loss: 3.5709
Iteration: 1101; Percent complete: 27.5%; Average loss: 3.6183
Iteration: 1102; Percent complete: 27.6%; Average loss: 3.4200
Iteration: 1103; Percent complete: 27.6%; Average loss: 3.3153
Iteration: 1104; Percent complete: 27.6%; Average loss: 3.3665
Iteration: 1105; Percent complete: 27.6%; Average loss: 3.0914
Iteration: 1106; Percent complete: 27.7%; Average loss: 3.3704
Iteration: 1107; Percent complete: 27.7%; Average loss: 3.2998
Iteration: 1108; Percent complete: 27.7%; Average loss: 3.4949
Iteration: 1109; Percent complete: 27.7%; Average loss: 3.4554
Iteration: 1110; Percent complete: 27.8%; Average loss: 3.4650
Iteration: 1111; Percent complete: 27.8%; Average loss: 3.4178
Iteration: 1112; Percent complete: 27.8%; Average loss: 3.5890
Iteration: 1113; Percent complete: 27.8%; Average loss: 3.5119
Iteration: 1114; Percent complete: 27.9%; Average loss: 3.6403
Iteration: 1115; Percent complete: 27.9%; Average loss: 3.3986
Iteration: 1116; Percent complete: 27.9%; Average loss: 3.4283
Iteration: 1117; Percent complete: 27.9%; Average loss: 3.3533
Iteration: 1118; Percent complete: 28.0%; Average loss: 3.4621
Iteration: 1119; Percent complete: 28.0%; Average loss: 3.2638
Iteration: 1120; Percent complete: 28.0%; Average loss: 3.3208
Iteration: 1121; Percent complete: 28.0%; Average loss: 3.4016
Iteration: 1122; Percent complete: 28.1%; Average loss: 3.3772
Iteration: 1123; Percent complete: 28.1%; Average loss: 3.4581
Iteration: 1124; Percent complete: 28.1%; Average loss: 3.3193
Iteration: 1125; Percent complete: 28.1%; Average loss: 3.5381
Iteration: 1126; Percent complete: 28.1%; Average loss: 3.2589
Iteration: 1127; Percent complete: 28.2%; Average loss: 3.1859
Iteration: 1128; Percent complete: 28.2%; Average loss: 3.5009
Iteration: 1129; Percent complete: 28.2%; Average loss: 3.4183
Iteration: 1130; Percent complete: 28.2%; Average loss: 3.4925
Iteration: 1131; Percent complete: 28.3%; Average loss: 3.3124
Iteration: 1132; Percent complete: 28.3%; Average loss: 3.4751
Iteration: 1133; Percent complete: 28.3%; Average loss: 3.2144
Iteration: 1134; Percent complete: 28.3%; Average loss: 3.3029
Iteration: 1135; Percent complete: 28.4%; Average loss: 3.4618
Iteration: 1136; Percent complete: 28.4%; Average loss: 3.3303
Iteration: 1137; Percent complete: 28.4%; Average loss: 3.5654
Iteration: 1138; Percent complete: 28.4%; Average loss: 3.5822
Iteration: 1139; Percent complete: 28.5%; Average loss: 3.4540
Iteration: 1140; Percent complete: 28.5%; Average loss: 3.5270
Iteration: 1141; Percent complete: 28.5%; Average loss: 3.5602
Iteration: 1142; Percent complete: 28.5%; Average loss: 3.5889
Iteration: 1143; Percent complete: 28.6%; Average loss: 3.3854
Iteration: 1144; Percent complete: 28.6%; Average loss: 3.3509
Iteration: 1145; Percent complete: 28.6%; Average loss: 3.2317
Iteration: 1146; Percent complete: 28.6%; Average loss: 3.3859
Iteration: 1147; Percent complete: 28.7%; Average loss: 3.3792
Iteration: 1148; Percent complete: 28.7%; Average loss: 3.3417
Iteration: 1149; Percent complete: 28.7%; Average loss: 3.5245
Iteration: 1150; Percent complete: 28.7%; Average loss: 3.1263
Iteration: 1151; Percent complete: 28.8%; Average loss: 3.3827
Iteration: 1152; Percent complete: 28.8%; Average loss: 3.4853
Iteration: 1153; Percent complete: 28.8%; Average loss: 3.5361
Iteration: 1154; Percent complete: 28.8%; Average loss: 3.3434
Iteration: 1155; Percent complete: 28.9%; Average loss: 3.4046
Iteration: 1156; Percent complete: 28.9%; Average loss: 3.5090
Iteration: 1157; Percent complete: 28.9%; Average loss: 3.4449
Iteration: 1158; Percent complete: 28.9%; Average loss: 3.2663
Iteration: 1159; Percent complete: 29.0%; Average loss: 3.3738
Iteration: 1160; Percent complete: 29.0%; Average loss: 3.4378
Iteration: 1161; Percent complete: 29.0%; Average loss: 3.4966
Iteration: 1162; Percent complete: 29.0%; Average loss: 3.2932
Iteration: 1163; Percent complete: 29.1%; Average loss: 3.5673
Iteration: 1164; Percent complete: 29.1%; Average loss: 3.4797
Iteration: 1165; Percent complete: 29.1%; Average loss: 3.3868
Iteration: 1166; Percent complete: 29.1%; Average loss: 3.5750
Iteration: 1167; Percent complete: 29.2%; Average loss: 3.7149
Iteration: 1168; Percent complete: 29.2%; Average loss: 3.3349
Iteration: 1169; Percent complete: 29.2%; Average loss: 3.3146
Iteration: 1170; Percent complete: 29.2%; Average loss: 3.4834
Iteration: 1171; Percent complete: 29.3%; Average loss: 3.5480
Iteration: 1172; Percent complete: 29.3%; Average loss: 3.3788
Iteration: 1173; Percent complete: 29.3%; Average loss: 3.4806
Iteration: 1174; Percent complete: 29.3%; Average loss: 3.6509
Iteration: 1175; Percent complete: 29.4%; Average loss: 3.4902
Iteration: 1176; Percent complete: 29.4%; Average loss: 3.4206
Iteration: 1177; Percent complete: 29.4%; Average loss: 3.4622
Iteration: 1178; Percent complete: 29.4%; Average loss: 3.2122
Iteration: 1179; Percent complete: 29.5%; Average loss: 3.4798
Iteration: 1180; Percent complete: 29.5%; Average loss: 3.3613
Iteration: 1181; Percent complete: 29.5%; Average loss: 3.6365
Iteration: 1182; Percent complete: 29.5%; Average loss: 3.2702
Iteration: 1183; Percent complete: 29.6%; Average loss: 3.2684
Iteration: 1184; Percent complete: 29.6%; Average loss: 3.4204
Iteration: 1185; Percent complete: 29.6%; Average loss: 3.5993
Iteration: 1186; Percent complete: 29.6%; Average loss: 3.5212
Iteration: 1187; Percent complete: 29.7%; Average loss: 3.0645
Iteration: 1188; Percent complete: 29.7%; Average loss: 3.2417
Iteration: 1189; Percent complete: 29.7%; Average loss: 3.4159
Iteration: 1190; Percent complete: 29.8%; Average loss: 3.5575
Iteration: 1191; Percent complete: 29.8%; Average loss: 3.5062
Iteration: 1192; Percent complete: 29.8%; Average loss: 3.3098
Iteration: 1193; Percent complete: 29.8%; Average loss: 3.2475
Iteration: 1194; Percent complete: 29.8%; Average loss: 3.3575
Iteration: 1195; Percent complete: 29.9%; Average loss: 3.6123
Iteration: 1196; Percent complete: 29.9%; Average loss: 3.1902
Iteration: 1197; Percent complete: 29.9%; Average loss: 3.6339
Iteration: 1198; Percent complete: 29.9%; Average loss: 3.5375
Iteration: 1199; Percent complete: 30.0%; Average loss: 3.3974
Iteration: 1200; Percent complete: 30.0%; Average loss: 3.3013
Iteration: 1201; Percent complete: 30.0%; Average loss: 3.4587
Iteration: 1202; Percent complete: 30.0%; Average loss: 3.4795
Iteration: 1203; Percent complete: 30.1%; Average loss: 2.9725
Iteration: 1204; Percent complete: 30.1%; Average loss: 3.4599
Iteration: 1205; Percent complete: 30.1%; Average loss: 3.6284
Iteration: 1206; Percent complete: 30.1%; Average loss: 3.3848
Iteration: 1207; Percent complete: 30.2%; Average loss: 3.5774
Iteration: 1208; Percent complete: 30.2%; Average loss: 3.5394
Iteration: 1209; Percent complete: 30.2%; Average loss: 3.5065
Iteration: 1210; Percent complete: 30.2%; Average loss: 3.4399
Iteration: 1211; Percent complete: 30.3%; Average loss: 3.3694
Iteration: 1212; Percent complete: 30.3%; Average loss: 3.8495
Iteration: 1213; Percent complete: 30.3%; Average loss: 3.3864
Iteration: 1214; Percent complete: 30.3%; Average loss: 3.2531
Iteration: 1215; Percent complete: 30.4%; Average loss: 3.1554
Iteration: 1216; Percent complete: 30.4%; Average loss: 3.6223
Iteration: 1217; Percent complete: 30.4%; Average loss: 3.6844
Iteration: 1218; Percent complete: 30.4%; Average loss: 3.0647
Iteration: 1219; Percent complete: 30.5%; Average loss: 3.4626
Iteration: 1220; Percent complete: 30.5%; Average loss: 3.5585
Iteration: 1221; Percent complete: 30.5%; Average loss: 3.4858
Iteration: 1222; Percent complete: 30.6%; Average loss: 3.3749
Iteration: 1223; Percent complete: 30.6%; Average loss: 3.4460
Iteration: 1224; Percent complete: 30.6%; Average loss: 3.4686
Iteration: 1225; Percent complete: 30.6%; Average loss: 3.5463
Iteration: 1226; Percent complete: 30.6%; Average loss: 3.2466
Iteration: 1227; Percent complete: 30.7%; Average loss: 3.2513
Iteration: 1228; Percent complete: 30.7%; Average loss: 3.2884
Iteration: 1229; Percent complete: 30.7%; Average loss: 3.3617
Iteration: 1230; Percent complete: 30.8%; Average loss: 3.3035
Iteration: 1231; Percent complete: 30.8%; Average loss: 3.1440
Iteration: 1232; Percent complete: 30.8%; Average loss: 3.2189
Iteration: 1233; Percent complete: 30.8%; Average loss: 3.7099
Iteration: 1234; Percent complete: 30.9%; Average loss: 3.5384
Iteration: 1235; Percent complete: 30.9%; Average loss: 3.4668
Iteration: 1236; Percent complete: 30.9%; Average loss: 3.4233
Iteration: 1237; Percent complete: 30.9%; Average loss: 3.1821
Iteration: 1238; Percent complete: 30.9%; Average loss: 3.4248
Iteration: 1239; Percent complete: 31.0%; Average loss: 3.2461
Iteration: 1240; Percent complete: 31.0%; Average loss: 3.5464
Iteration: 1241; Percent complete: 31.0%; Average loss: 3.2810
Iteration: 1242; Percent complete: 31.1%; Average loss: 3.3539
Iteration: 1243; Percent complete: 31.1%; Average loss: 3.2126
Iteration: 1244; Percent complete: 31.1%; Average loss: 3.2614
Iteration: 1245; Percent complete: 31.1%; Average loss: 3.1433
Iteration: 1246; Percent complete: 31.1%; Average loss: 3.3759
Iteration: 1247; Percent complete: 31.2%; Average loss: 3.4842
Iteration: 1248; Percent complete: 31.2%; Average loss: 3.3206
Iteration: 1249; Percent complete: 31.2%; Average loss: 3.5508
Iteration: 1250; Percent complete: 31.2%; Average loss: 3.2729
Iteration: 1251; Percent complete: 31.3%; Average loss: 3.2718
Iteration: 1252; Percent complete: 31.3%; Average loss: 3.3307
Iteration: 1253; Percent complete: 31.3%; Average loss: 3.4969
Iteration: 1254; Percent complete: 31.4%; Average loss: 3.4247
Iteration: 1255; Percent complete: 31.4%; Average loss: 3.1798
Iteration: 1256; Percent complete: 31.4%; Average loss: 3.3269
Iteration: 1257; Percent complete: 31.4%; Average loss: 3.6354
Iteration: 1258; Percent complete: 31.4%; Average loss: 3.5093
Iteration: 1259; Percent complete: 31.5%; Average loss: 3.2626
Iteration: 1260; Percent complete: 31.5%; Average loss: 3.5990
Iteration: 1261; Percent complete: 31.5%; Average loss: 3.0681
Iteration: 1262; Percent complete: 31.6%; Average loss: 3.2437
Iteration: 1263; Percent complete: 31.6%; Average loss: 3.5857
Iteration: 1264; Percent complete: 31.6%; Average loss: 3.4144
Iteration: 1265; Percent complete: 31.6%; Average loss: 3.3368
Iteration: 1266; Percent complete: 31.6%; Average loss: 3.3420
Iteration: 1267; Percent complete: 31.7%; Average loss: 3.3772
Iteration: 1268; Percent complete: 31.7%; Average loss: 3.2920
Iteration: 1269; Percent complete: 31.7%; Average loss: 3.5000
Iteration: 1270; Percent complete: 31.8%; Average loss: 3.2847
Iteration: 1271; Percent complete: 31.8%; Average loss: 3.4101
Iteration: 1272; Percent complete: 31.8%; Average loss: 3.1986
Iteration: 1273; Percent complete: 31.8%; Average loss: 3.3360
Iteration: 1274; Percent complete: 31.9%; Average loss: 3.1581
Iteration: 1275; Percent complete: 31.9%; Average loss: 3.6084
Iteration: 1276; Percent complete: 31.9%; Average loss: 3.3391
Iteration: 1277; Percent complete: 31.9%; Average loss: 3.4721
Iteration: 1278; Percent complete: 31.9%; Average loss: 3.1546
Iteration: 1279; Percent complete: 32.0%; Average loss: 3.3051
Iteration: 1280; Percent complete: 32.0%; Average loss: 3.4686
Iteration: 1281; Percent complete: 32.0%; Average loss: 3.1970
Iteration: 1282; Percent complete: 32.0%; Average loss: 3.3286
Iteration: 1283; Percent complete: 32.1%; Average loss: 3.1888
Iteration: 1284; Percent complete: 32.1%; Average loss: 3.6094
Iteration: 1285; Percent complete: 32.1%; Average loss: 3.2812
Iteration: 1286; Percent complete: 32.1%; Average loss: 3.3508
Iteration: 1287; Percent complete: 32.2%; Average loss: 3.4129
Iteration: 1288; Percent complete: 32.2%; Average loss: 3.3957
Iteration: 1289; Percent complete: 32.2%; Average loss: 3.1765
Iteration: 1290; Percent complete: 32.2%; Average loss: 3.4567
Iteration: 1291; Percent complete: 32.3%; Average loss: 3.2926
Iteration: 1292; Percent complete: 32.3%; Average loss: 3.2351
Iteration: 1293; Percent complete: 32.3%; Average loss: 3.5226
Iteration: 1294; Percent complete: 32.4%; Average loss: 3.7097
Iteration: 1295; Percent complete: 32.4%; Average loss: 3.0306
Iteration: 1296; Percent complete: 32.4%; Average loss: 3.6091
Iteration: 1297; Percent complete: 32.4%; Average loss: 3.5153
Iteration: 1298; Percent complete: 32.5%; Average loss: 3.4014
Iteration: 1299; Percent complete: 32.5%; Average loss: 3.3031
Iteration: 1300; Percent complete: 32.5%; Average loss: 3.3274
Iteration: 1301; Percent complete: 32.5%; Average loss: 3.3718
Iteration: 1302; Percent complete: 32.6%; Average loss: 3.1966
Iteration: 1303; Percent complete: 32.6%; Average loss: 3.3645
Iteration: 1304; Percent complete: 32.6%; Average loss: 3.3552
Iteration: 1305; Percent complete: 32.6%; Average loss: 3.3686
Iteration: 1306; Percent complete: 32.6%; Average loss: 3.1661
Iteration: 1307; Percent complete: 32.7%; Average loss: 3.3596
Iteration: 1308; Percent complete: 32.7%; Average loss: 3.4703
Iteration: 1309; Percent complete: 32.7%; Average loss: 3.2557
Iteration: 1310; Percent complete: 32.8%; Average loss: 3.5135
Iteration: 1311; Percent complete: 32.8%; Average loss: 3.3681
Iteration: 1312; Percent complete: 32.8%; Average loss: 3.7744
Iteration: 1313; Percent complete: 32.8%; Average loss: 3.4493
Iteration: 1314; Percent complete: 32.9%; Average loss: 3.5193
Iteration: 1315; Percent complete: 32.9%; Average loss: 3.4766
Iteration: 1316; Percent complete: 32.9%; Average loss: 3.5464
Iteration: 1317; Percent complete: 32.9%; Average loss: 3.5373
Iteration: 1318; Percent complete: 33.0%; Average loss: 3.2801
Iteration: 1319; Percent complete: 33.0%; Average loss: 3.2311
Iteration: 1320; Percent complete: 33.0%; Average loss: 3.7062
Iteration: 1321; Percent complete: 33.0%; Average loss: 3.2507
Iteration: 1322; Percent complete: 33.1%; Average loss: 3.3002
Iteration: 1323; Percent complete: 33.1%; Average loss: 3.4843
Iteration: 1324; Percent complete: 33.1%; Average loss: 3.5206
Iteration: 1325; Percent complete: 33.1%; Average loss: 3.4271
Iteration: 1326; Percent complete: 33.1%; Average loss: 3.3757
Iteration: 1327; Percent complete: 33.2%; Average loss: 3.3189
Iteration: 1328; Percent complete: 33.2%; Average loss: 3.6704
Iteration: 1329; Percent complete: 33.2%; Average loss: 3.2208
Iteration: 1330; Percent complete: 33.2%; Average loss: 3.6324
Iteration: 1331; Percent complete: 33.3%; Average loss: 3.3403
Iteration: 1332; Percent complete: 33.3%; Average loss: 3.2916
Iteration: 1333; Percent complete: 33.3%; Average loss: 3.4092
Iteration: 1334; Percent complete: 33.4%; Average loss: 3.3370
Iteration: 1335; Percent complete: 33.4%; Average loss: 3.3354
Iteration: 1336; Percent complete: 33.4%; Average loss: 3.3437
Iteration: 1337; Percent complete: 33.4%; Average loss: 3.4295
Iteration: 1338; Percent complete: 33.5%; Average loss: 3.3599
Iteration: 1339; Percent complete: 33.5%; Average loss: 3.3319
Iteration: 1340; Percent complete: 33.5%; Average loss: 3.4910
Iteration: 1341; Percent complete: 33.5%; Average loss: 3.3150
Iteration: 1342; Percent complete: 33.6%; Average loss: 3.2197
Iteration: 1343; Percent complete: 33.6%; Average loss: 3.3036
Iteration: 1344; Percent complete: 33.6%; Average loss: 3.2618
Iteration: 1345; Percent complete: 33.6%; Average loss: 3.4694
Iteration: 1346; Percent complete: 33.7%; Average loss: 3.3072
Iteration: 1347; Percent complete: 33.7%; Average loss: 3.3535
Iteration: 1348; Percent complete: 33.7%; Average loss: 3.3965
Iteration: 1349; Percent complete: 33.7%; Average loss: 3.1815
Iteration: 1350; Percent complete: 33.8%; Average loss: 3.1768
Iteration: 1351; Percent complete: 33.8%; Average loss: 3.5025
Iteration: 1352; Percent complete: 33.8%; Average loss: 3.1700
Iteration: 1353; Percent complete: 33.8%; Average loss: 3.5090
Iteration: 1354; Percent complete: 33.9%; Average loss: 3.1624
Iteration: 1355; Percent complete: 33.9%; Average loss: 3.4867
Iteration: 1356; Percent complete: 33.9%; Average loss: 3.3056
Iteration: 1357; Percent complete: 33.9%; Average loss: 3.2832
Iteration: 1358; Percent complete: 34.0%; Average loss: 3.2449
Iteration: 1359; Percent complete: 34.0%; Average loss: 3.3986
Iteration: 1360; Percent complete: 34.0%; Average loss: 3.1871
Iteration: 1361; Percent complete: 34.0%; Average loss: 3.2378
Iteration: 1362; Percent complete: 34.1%; Average loss: 3.4866
Iteration: 1363; Percent complete: 34.1%; Average loss: 3.0328
Iteration: 1364; Percent complete: 34.1%; Average loss: 3.1526
Iteration: 1365; Percent complete: 34.1%; Average loss: 2.8984
Iteration: 1366; Percent complete: 34.2%; Average loss: 3.3809
Iteration: 1367; Percent complete: 34.2%; Average loss: 3.7251
Iteration: 1368; Percent complete: 34.2%; Average loss: 3.2152
Iteration: 1369; Percent complete: 34.2%; Average loss: 3.1862
Iteration: 1370; Percent complete: 34.2%; Average loss: 3.2799
Iteration: 1371; Percent complete: 34.3%; Average loss: 3.5224
Iteration: 1372; Percent complete: 34.3%; Average loss: 3.4257
Iteration: 1373; Percent complete: 34.3%; Average loss: 3.3059
Iteration: 1374; Percent complete: 34.4%; Average loss: 3.1859
Iteration: 1375; Percent complete: 34.4%; Average loss: 3.3835
Iteration: 1376; Percent complete: 34.4%; Average loss: 3.5198
Iteration: 1377; Percent complete: 34.4%; Average loss: 3.4703
Iteration: 1378; Percent complete: 34.4%; Average loss: 3.4347
Iteration: 1379; Percent complete: 34.5%; Average loss: 3.4225
Iteration: 1380; Percent complete: 34.5%; Average loss: 3.3424
Iteration: 1381; Percent complete: 34.5%; Average loss: 3.2228
Iteration: 1382; Percent complete: 34.5%; Average loss: 3.2830
Iteration: 1383; Percent complete: 34.6%; Average loss: 3.3360
Iteration: 1384; Percent complete: 34.6%; Average loss: 3.0563
Iteration: 1385; Percent complete: 34.6%; Average loss: 3.2347
Iteration: 1386; Percent complete: 34.6%; Average loss: 3.4977
Iteration: 1387; Percent complete: 34.7%; Average loss: 3.3019
Iteration: 1388; Percent complete: 34.7%; Average loss: 3.1287
Iteration: 1389; Percent complete: 34.7%; Average loss: 3.5224
Iteration: 1390; Percent complete: 34.8%; Average loss: 3.5460
Iteration: 1391; Percent complete: 34.8%; Average loss: 3.3753
Iteration: 1392; Percent complete: 34.8%; Average loss: 3.5138
Iteration: 1393; Percent complete: 34.8%; Average loss: 3.5595
Iteration: 1394; Percent complete: 34.8%; Average loss: 3.1235
Iteration: 1395; Percent complete: 34.9%; Average loss: 3.2596
Iteration: 1396; Percent complete: 34.9%; Average loss: 3.3859
Iteration: 1397; Percent complete: 34.9%; Average loss: 3.2403
Iteration: 1398; Percent complete: 34.9%; Average loss: 3.2180
Iteration: 1399; Percent complete: 35.0%; Average loss: 3.1848
Iteration: 1400; Percent complete: 35.0%; Average loss: 2.9467
Iteration: 1401; Percent complete: 35.0%; Average loss: 3.1928
Iteration: 1402; Percent complete: 35.0%; Average loss: 3.5461
Iteration: 1403; Percent complete: 35.1%; Average loss: 3.5289
Iteration: 1404; Percent complete: 35.1%; Average loss: 3.1748
Iteration: 1405; Percent complete: 35.1%; Average loss: 3.5186
Iteration: 1406; Percent complete: 35.1%; Average loss: 3.4889
Iteration: 1407; Percent complete: 35.2%; Average loss: 3.4911
Iteration: 1408; Percent complete: 35.2%; Average loss: 3.2804
Iteration: 1409; Percent complete: 35.2%; Average loss: 3.3927
Iteration: 1410; Percent complete: 35.2%; Average loss: 3.3054
Iteration: 1411; Percent complete: 35.3%; Average loss: 3.4905
Iteration: 1412; Percent complete: 35.3%; Average loss: 3.3504
Iteration: 1413; Percent complete: 35.3%; Average loss: 3.2274
Iteration: 1414; Percent complete: 35.4%; Average loss: 3.1928
Iteration: 1415; Percent complete: 35.4%; Average loss: 3.3236
Iteration: 1416; Percent complete: 35.4%; Average loss: 3.5681
Iteration: 1417; Percent complete: 35.4%; Average loss: 3.4620
Iteration: 1418; Percent complete: 35.4%; Average loss: 3.2097
Iteration: 1419; Percent complete: 35.5%; Average loss: 3.2344
Iteration: 1420; Percent complete: 35.5%; Average loss: 3.0382
Iteration: 1421; Percent complete: 35.5%; Average loss: 3.1187
Iteration: 1422; Percent complete: 35.5%; Average loss: 3.5850
Iteration: 1423; Percent complete: 35.6%; Average loss: 3.1752
Iteration: 1424; Percent complete: 35.6%; Average loss: 3.3196
Iteration: 1425; Percent complete: 35.6%; Average loss: 3.4268
Iteration: 1426; Percent complete: 35.6%; Average loss: 3.1791
Iteration: 1427; Percent complete: 35.7%; Average loss: 3.4778
Iteration: 1428; Percent complete: 35.7%; Average loss: 3.4916
Iteration: 1429; Percent complete: 35.7%; Average loss: 3.3858
Iteration: 1430; Percent complete: 35.8%; Average loss: 3.2298
Iteration: 1431; Percent complete: 35.8%; Average loss: 3.4501
Iteration: 1432; Percent complete: 35.8%; Average loss: 3.4073
Iteration: 1433; Percent complete: 35.8%; Average loss: 3.4251
Iteration: 1434; Percent complete: 35.9%; Average loss: 3.1424
Iteration: 1435; Percent complete: 35.9%; Average loss: 3.4583
Iteration: 1436; Percent complete: 35.9%; Average loss: 3.1142
Iteration: 1437; Percent complete: 35.9%; Average loss: 3.5569
Iteration: 1438; Percent complete: 35.9%; Average loss: 3.1330
Iteration: 1439; Percent complete: 36.0%; Average loss: 3.3155
Iteration: 1440; Percent complete: 36.0%; Average loss: 3.1791
Iteration: 1441; Percent complete: 36.0%; Average loss: 3.4097
Iteration: 1442; Percent complete: 36.0%; Average loss: 3.4112
Iteration: 1443; Percent complete: 36.1%; Average loss: 3.2590
Iteration: 1444; Percent complete: 36.1%; Average loss: 3.4344
Iteration: 1445; Percent complete: 36.1%; Average loss: 3.2531
Iteration: 1446; Percent complete: 36.1%; Average loss: 3.0686
Iteration: 1447; Percent complete: 36.2%; Average loss: 3.1759
Iteration: 1448; Percent complete: 36.2%; Average loss: 3.3768
Iteration: 1449; Percent complete: 36.2%; Average loss: 3.1678
Iteration: 1450; Percent complete: 36.2%; Average loss: 3.2226
Iteration: 1451; Percent complete: 36.3%; Average loss: 3.2012
Iteration: 1452; Percent complete: 36.3%; Average loss: 3.1930
Iteration: 1453; Percent complete: 36.3%; Average loss: 3.2716
Iteration: 1454; Percent complete: 36.4%; Average loss: 3.4132
Iteration: 1455; Percent complete: 36.4%; Average loss: 3.2689
Iteration: 1456; Percent complete: 36.4%; Average loss: 3.2001
Iteration: 1457; Percent complete: 36.4%; Average loss: 3.0248
Iteration: 1458; Percent complete: 36.4%; Average loss: 3.6073
Iteration: 1459; Percent complete: 36.5%; Average loss: 3.2789
Iteration: 1460; Percent complete: 36.5%; Average loss: 3.2305
Iteration: 1461; Percent complete: 36.5%; Average loss: 3.3844
Iteration: 1462; Percent complete: 36.5%; Average loss: 3.1335
Iteration: 1463; Percent complete: 36.6%; Average loss: 3.3722
Iteration: 1464; Percent complete: 36.6%; Average loss: 3.5721
Iteration: 1465; Percent complete: 36.6%; Average loss: 3.2432
Iteration: 1466; Percent complete: 36.6%; Average loss: 3.3506
Iteration: 1467; Percent complete: 36.7%; Average loss: 3.2022
Iteration: 1468; Percent complete: 36.7%; Average loss: 3.0890
Iteration: 1469; Percent complete: 36.7%; Average loss: 3.2589
Iteration: 1470; Percent complete: 36.8%; Average loss: 3.3913
Iteration: 1471; Percent complete: 36.8%; Average loss: 3.1583
Iteration: 1472; Percent complete: 36.8%; Average loss: 3.3734
Iteration: 1473; Percent complete: 36.8%; Average loss: 3.2700
Iteration: 1474; Percent complete: 36.9%; Average loss: 3.2443
Iteration: 1475; Percent complete: 36.9%; Average loss: 3.1768
Iteration: 1476; Percent complete: 36.9%; Average loss: 3.5505
Iteration: 1477; Percent complete: 36.9%; Average loss: 3.1664
Iteration: 1478; Percent complete: 37.0%; Average loss: 3.1759
Iteration: 1479; Percent complete: 37.0%; Average loss: 3.0218
Iteration: 1480; Percent complete: 37.0%; Average loss: 3.4296
Iteration: 1481; Percent complete: 37.0%; Average loss: 3.3070
Iteration: 1482; Percent complete: 37.0%; Average loss: 3.1411
Iteration: 1483; Percent complete: 37.1%; Average loss: 3.0728
Iteration: 1484; Percent complete: 37.1%; Average loss: 3.6083
Iteration: 1485; Percent complete: 37.1%; Average loss: 3.2287
Iteration: 1486; Percent complete: 37.1%; Average loss: 3.2301
Iteration: 1487; Percent complete: 37.2%; Average loss: 3.6244
Iteration: 1488; Percent complete: 37.2%; Average loss: 3.3827
Iteration: 1489; Percent complete: 37.2%; Average loss: 3.3124
Iteration: 1490; Percent complete: 37.2%; Average loss: 3.2982
Iteration: 1491; Percent complete: 37.3%; Average loss: 3.2415
Iteration: 1492; Percent complete: 37.3%; Average loss: 3.1787
Iteration: 1493; Percent complete: 37.3%; Average loss: 3.1998
Iteration: 1494; Percent complete: 37.4%; Average loss: 3.2029
Iteration: 1495; Percent complete: 37.4%; Average loss: 3.3382
Iteration: 1496; Percent complete: 37.4%; Average loss: 3.3859
Iteration: 1497; Percent complete: 37.4%; Average loss: 3.2975
Iteration: 1498; Percent complete: 37.5%; Average loss: 3.3190
Iteration: 1499; Percent complete: 37.5%; Average loss: 3.2631
Iteration: 1500; Percent complete: 37.5%; Average loss: 3.2661
Iteration: 1501; Percent complete: 37.5%; Average loss: 3.2508
Iteration: 1502; Percent complete: 37.5%; Average loss: 3.2201
Iteration: 1503; Percent complete: 37.6%; Average loss: 3.2771
Iteration: 1504; Percent complete: 37.6%; Average loss: 3.4063
Iteration: 1505; Percent complete: 37.6%; Average loss: 3.1070
Iteration: 1506; Percent complete: 37.6%; Average loss: 3.2084
Iteration: 1507; Percent complete: 37.7%; Average loss: 3.5528
Iteration: 1508; Percent complete: 37.7%; Average loss: 3.2053
Iteration: 1509; Percent complete: 37.7%; Average loss: 3.1945
Iteration: 1510; Percent complete: 37.8%; Average loss: 3.1705
Iteration: 1511; Percent complete: 37.8%; Average loss: 3.3962
Iteration: 1512; Percent complete: 37.8%; Average loss: 3.0058
Iteration: 1513; Percent complete: 37.8%; Average loss: 3.1593
Iteration: 1514; Percent complete: 37.9%; Average loss: 3.5848
Iteration: 1515; Percent complete: 37.9%; Average loss: 3.1385
Iteration: 1516; Percent complete: 37.9%; Average loss: 3.3557
Iteration: 1517; Percent complete: 37.9%; Average loss: 3.4475
Iteration: 1518; Percent complete: 38.0%; Average loss: 3.1781
Iteration: 1519; Percent complete: 38.0%; Average loss: 3.0032
Iteration: 1520; Percent complete: 38.0%; Average loss: 3.4432
Iteration: 1521; Percent complete: 38.0%; Average loss: 3.3981
Iteration: 1522; Percent complete: 38.0%; Average loss: 3.5539
Iteration: 1523; Percent complete: 38.1%; Average loss: 3.6350
Iteration: 1524; Percent complete: 38.1%; Average loss: 3.5200
Iteration: 1525; Percent complete: 38.1%; Average loss: 3.4289
Iteration: 1526; Percent complete: 38.1%; Average loss: 3.0312
Iteration: 1527; Percent complete: 38.2%; Average loss: 3.3891
Iteration: 1528; Percent complete: 38.2%; Average loss: 3.4248
Iteration: 1529; Percent complete: 38.2%; Average loss: 3.5752
Iteration: 1530; Percent complete: 38.2%; Average loss: 3.3477
Iteration: 1531; Percent complete: 38.3%; Average loss: 3.4317
Iteration: 1532; Percent complete: 38.3%; Average loss: 3.3824
Iteration: 1533; Percent complete: 38.3%; Average loss: 3.2517
Iteration: 1534; Percent complete: 38.4%; Average loss: 3.2888
Iteration: 1535; Percent complete: 38.4%; Average loss: 3.2112
Iteration: 1536; Percent complete: 38.4%; Average loss: 3.7248
Iteration: 1537; Percent complete: 38.4%; Average loss: 3.1436
Iteration: 1538; Percent complete: 38.5%; Average loss: 3.2147
Iteration: 1539; Percent complete: 38.5%; Average loss: 3.3638
Iteration: 1540; Percent complete: 38.5%; Average loss: 3.2080
Iteration: 1541; Percent complete: 38.5%; Average loss: 3.1070
Iteration: 1542; Percent complete: 38.6%; Average loss: 3.3399
Iteration: 1543; Percent complete: 38.6%; Average loss: 3.4665
Iteration: 1544; Percent complete: 38.6%; Average loss: 3.4859
Iteration: 1545; Percent complete: 38.6%; Average loss: 3.4315
Iteration: 1546; Percent complete: 38.6%; Average loss: 3.2213
Iteration: 1547; Percent complete: 38.7%; Average loss: 3.2039
Iteration: 1548; Percent complete: 38.7%; Average loss: 3.4073
Iteration: 1549; Percent complete: 38.7%; Average loss: 3.3802
Iteration: 1550; Percent complete: 38.8%; Average loss: 3.1775
Iteration: 1551; Percent complete: 38.8%; Average loss: 3.1943
Iteration: 1552; Percent complete: 38.8%; Average loss: 3.6174
Iteration: 1553; Percent complete: 38.8%; Average loss: 3.1440
Iteration: 1554; Percent complete: 38.9%; Average loss: 3.4082
Iteration: 1555; Percent complete: 38.9%; Average loss: 3.3501
Iteration: 1556; Percent complete: 38.9%; Average loss: 3.1427
Iteration: 1557; Percent complete: 38.9%; Average loss: 3.4223
Iteration: 1558; Percent complete: 39.0%; Average loss: 3.2436
Iteration: 1559; Percent complete: 39.0%; Average loss: 3.2755
Iteration: 1560; Percent complete: 39.0%; Average loss: 3.3685
Iteration: 1561; Percent complete: 39.0%; Average loss: 3.3041
Iteration: 1562; Percent complete: 39.1%; Average loss: 3.3001
Iteration: 1563; Percent complete: 39.1%; Average loss: 3.3795
Iteration: 1564; Percent complete: 39.1%; Average loss: 3.2244
Iteration: 1565; Percent complete: 39.1%; Average loss: 3.3311
Iteration: 1566; Percent complete: 39.1%; Average loss: 3.0399
Iteration: 1567; Percent complete: 39.2%; Average loss: 3.3070
Iteration: 1568; Percent complete: 39.2%; Average loss: 3.2900
Iteration: 1569; Percent complete: 39.2%; Average loss: 3.3848
Iteration: 1570; Percent complete: 39.2%; Average loss: 3.0122
Iteration: 1571; Percent complete: 39.3%; Average loss: 3.3741
Iteration: 1572; Percent complete: 39.3%; Average loss: 3.5175
Iteration: 1573; Percent complete: 39.3%; Average loss: 3.1401
Iteration: 1574; Percent complete: 39.4%; Average loss: 3.1883
Iteration: 1575; Percent complete: 39.4%; Average loss: 3.4040
Iteration: 1576; Percent complete: 39.4%; Average loss: 3.5211
Iteration: 1577; Percent complete: 39.4%; Average loss: 3.3801
Iteration: 1578; Percent complete: 39.5%; Average loss: 3.3012
Iteration: 1579; Percent complete: 39.5%; Average loss: 3.1619
Iteration: 1580; Percent complete: 39.5%; Average loss: 3.0347
Iteration: 1581; Percent complete: 39.5%; Average loss: 3.2949
Iteration: 1582; Percent complete: 39.6%; Average loss: 3.2858
Iteration: 1583; Percent complete: 39.6%; Average loss: 3.6225
Iteration: 1584; Percent complete: 39.6%; Average loss: 3.3131
Iteration: 1585; Percent complete: 39.6%; Average loss: 3.4015
Iteration: 1586; Percent complete: 39.6%; Average loss: 3.5885
Iteration: 1587; Percent complete: 39.7%; Average loss: 3.4845
Iteration: 1588; Percent complete: 39.7%; Average loss: 3.2590
Iteration: 1589; Percent complete: 39.7%; Average loss: 3.1882
Iteration: 1590; Percent complete: 39.8%; Average loss: 3.2339
Iteration: 1591; Percent complete: 39.8%; Average loss: 3.1875
Iteration: 1592; Percent complete: 39.8%; Average loss: 3.2740
Iteration: 1593; Percent complete: 39.8%; Average loss: 3.3876
Iteration: 1594; Percent complete: 39.9%; Average loss: 3.0885
Iteration: 1595; Percent complete: 39.9%; Average loss: 3.0793
Iteration: 1596; Percent complete: 39.9%; Average loss: 3.3179
Iteration: 1597; Percent complete: 39.9%; Average loss: 3.2434
Iteration: 1598; Percent complete: 40.0%; Average loss: 3.5474
Iteration: 1599; Percent complete: 40.0%; Average loss: 3.3888
Iteration: 1600; Percent complete: 40.0%; Average loss: 3.2704
Iteration: 1601; Percent complete: 40.0%; Average loss: 3.3120
Iteration: 1602; Percent complete: 40.1%; Average loss: 3.4264
Iteration: 1603; Percent complete: 40.1%; Average loss: 3.4026
Iteration: 1604; Percent complete: 40.1%; Average loss: 3.1371
Iteration: 1605; Percent complete: 40.1%; Average loss: 3.1339
Iteration: 1606; Percent complete: 40.2%; Average loss: 3.3680
Iteration: 1607; Percent complete: 40.2%; Average loss: 3.3753
Iteration: 1608; Percent complete: 40.2%; Average loss: 3.3737
Iteration: 1609; Percent complete: 40.2%; Average loss: 3.2542
Iteration: 1610; Percent complete: 40.2%; Average loss: 3.1185
Iteration: 1611; Percent complete: 40.3%; Average loss: 3.3690
Iteration: 1612; Percent complete: 40.3%; Average loss: 3.1554
Iteration: 1613; Percent complete: 40.3%; Average loss: 3.2776
Iteration: 1614; Percent complete: 40.4%; Average loss: 3.0219
Iteration: 1615; Percent complete: 40.4%; Average loss: 3.1809
Iteration: 1616; Percent complete: 40.4%; Average loss: 3.3777
Iteration: 1617; Percent complete: 40.4%; Average loss: 3.1085
Iteration: 1618; Percent complete: 40.5%; Average loss: 3.2027
Iteration: 1619; Percent complete: 40.5%; Average loss: 3.1384
Iteration: 1620; Percent complete: 40.5%; Average loss: 3.3150
Iteration: 1621; Percent complete: 40.5%; Average loss: 3.2128
Iteration: 1622; Percent complete: 40.6%; Average loss: 3.1373
Iteration: 1623; Percent complete: 40.6%; Average loss: 3.1902
Iteration: 1624; Percent complete: 40.6%; Average loss: 3.4771
Iteration: 1625; Percent complete: 40.6%; Average loss: 3.3062
Iteration: 1626; Percent complete: 40.6%; Average loss: 3.2109
Iteration: 1627; Percent complete: 40.7%; Average loss: 3.3531
Iteration: 1628; Percent complete: 40.7%; Average loss: 3.1470
Iteration: 1629; Percent complete: 40.7%; Average loss: 3.2853
Iteration: 1630; Percent complete: 40.8%; Average loss: 3.1986
Iteration: 1631; Percent complete: 40.8%; Average loss: 3.1689
Iteration: 1632; Percent complete: 40.8%; Average loss: 3.3526
Iteration: 1633; Percent complete: 40.8%; Average loss: 3.4091
Iteration: 1634; Percent complete: 40.8%; Average loss: 3.1587
Iteration: 1635; Percent complete: 40.9%; Average loss: 3.1011
Iteration: 1636; Percent complete: 40.9%; Average loss: 3.4341
Iteration: 1637; Percent complete: 40.9%; Average loss: 3.3716
Iteration: 1638; Percent complete: 40.9%; Average loss: 3.1592
Iteration: 1639; Percent complete: 41.0%; Average loss: 3.2905
Iteration: 1640; Percent complete: 41.0%; Average loss: 3.5618
Iteration: 1641; Percent complete: 41.0%; Average loss: 3.0676
Iteration: 1642; Percent complete: 41.0%; Average loss: 3.1794
Iteration: 1643; Percent complete: 41.1%; Average loss: 3.1280
Iteration: 1644; Percent complete: 41.1%; Average loss: 3.2143
Iteration: 1645; Percent complete: 41.1%; Average loss: 3.3588
Iteration: 1646; Percent complete: 41.1%; Average loss: 3.1444
Iteration: 1647; Percent complete: 41.2%; Average loss: 3.7644
Iteration: 1648; Percent complete: 41.2%; Average loss: 3.3384
Iteration: 1649; Percent complete: 41.2%; Average loss: 3.3221
Iteration: 1650; Percent complete: 41.2%; Average loss: 3.3430
Iteration: 1651; Percent complete: 41.3%; Average loss: 3.2626
Iteration: 1652; Percent complete: 41.3%; Average loss: 3.2060
Iteration: 1653; Percent complete: 41.3%; Average loss: 3.0607
Iteration: 1654; Percent complete: 41.3%; Average loss: 3.3713
Iteration: 1655; Percent complete: 41.4%; Average loss: 3.3236
Iteration: 1656; Percent complete: 41.4%; Average loss: 3.2544
Iteration: 1657; Percent complete: 41.4%; Average loss: 3.4606
Iteration: 1658; Percent complete: 41.4%; Average loss: 3.1115
Iteration: 1659; Percent complete: 41.5%; Average loss: 3.3835
Iteration: 1660; Percent complete: 41.5%; Average loss: 3.4132
Iteration: 1661; Percent complete: 41.5%; Average loss: 3.1607
Iteration: 1662; Percent complete: 41.5%; Average loss: 3.1842
Iteration: 1663; Percent complete: 41.6%; Average loss: 3.0537
Iteration: 1664; Percent complete: 41.6%; Average loss: 3.1727
Iteration: 1665; Percent complete: 41.6%; Average loss: 3.2980
Iteration: 1666; Percent complete: 41.6%; Average loss: 3.2996
Iteration: 1667; Percent complete: 41.7%; Average loss: 3.2951
Iteration: 1668; Percent complete: 41.7%; Average loss: 3.1720
Iteration: 1669; Percent complete: 41.7%; Average loss: 3.4298
Iteration: 1670; Percent complete: 41.8%; Average loss: 3.4407
Iteration: 1671; Percent complete: 41.8%; Average loss: 3.3203
Iteration: 1672; Percent complete: 41.8%; Average loss: 3.2094
Iteration: 1673; Percent complete: 41.8%; Average loss: 3.1656
Iteration: 1674; Percent complete: 41.9%; Average loss: 3.3254
Iteration: 1675; Percent complete: 41.9%; Average loss: 3.3041
Iteration: 1676; Percent complete: 41.9%; Average loss: 3.2494
Iteration: 1677; Percent complete: 41.9%; Average loss: 2.8673
Iteration: 1678; Percent complete: 41.9%; Average loss: 3.3105
Iteration: 1679; Percent complete: 42.0%; Average loss: 2.9996
Iteration: 1680; Percent complete: 42.0%; Average loss: 3.4765
Iteration: 1681; Percent complete: 42.0%; Average loss: 3.1380
Iteration: 1682; Percent complete: 42.0%; Average loss: 3.2934
Iteration: 1683; Percent complete: 42.1%; Average loss: 3.2858
Iteration: 1684; Percent complete: 42.1%; Average loss: 3.4919
Iteration: 1685; Percent complete: 42.1%; Average loss: 3.1900
Iteration: 1686; Percent complete: 42.1%; Average loss: 3.3939
Iteration: 1687; Percent complete: 42.2%; Average loss: 3.1176
Iteration: 1688; Percent complete: 42.2%; Average loss: 3.1283
Iteration: 1689; Percent complete: 42.2%; Average loss: 3.0445
Iteration: 1690; Percent complete: 42.2%; Average loss: 3.4184
Iteration: 1691; Percent complete: 42.3%; Average loss: 3.2849
Iteration: 1692; Percent complete: 42.3%; Average loss: 3.3491
Iteration: 1693; Percent complete: 42.3%; Average loss: 3.2326
Iteration: 1694; Percent complete: 42.4%; Average loss: 3.3842
Iteration: 1695; Percent complete: 42.4%; Average loss: 3.1131
Iteration: 1696; Percent complete: 42.4%; Average loss: 3.3004
Iteration: 1697; Percent complete: 42.4%; Average loss: 3.3007
Iteration: 1698; Percent complete: 42.4%; Average loss: 3.3296
Iteration: 1699; Percent complete: 42.5%; Average loss: 3.0185
Iteration: 1700; Percent complete: 42.5%; Average loss: 3.0761
Iteration: 1701; Percent complete: 42.5%; Average loss: 3.3016
Iteration: 1702; Percent complete: 42.5%; Average loss: 3.2230
Iteration: 1703; Percent complete: 42.6%; Average loss: 3.4898
Iteration: 1704; Percent complete: 42.6%; Average loss: 3.2262
Iteration: 1705; Percent complete: 42.6%; Average loss: 3.1678
Iteration: 1706; Percent complete: 42.6%; Average loss: 3.4170
Iteration: 1707; Percent complete: 42.7%; Average loss: 3.0640
Iteration: 1708; Percent complete: 42.7%; Average loss: 3.2313
Iteration: 1709; Percent complete: 42.7%; Average loss: 3.4626
Iteration: 1710; Percent complete: 42.8%; Average loss: 3.2076
Iteration: 1711; Percent complete: 42.8%; Average loss: 2.9681
Iteration: 1712; Percent complete: 42.8%; Average loss: 3.2241
Iteration: 1713; Percent complete: 42.8%; Average loss: 3.2410
Iteration: 1714; Percent complete: 42.9%; Average loss: 3.0961
Iteration: 1715; Percent complete: 42.9%; Average loss: 3.0815
Iteration: 1716; Percent complete: 42.9%; Average loss: 3.2679
Iteration: 1717; Percent complete: 42.9%; Average loss: 3.3636
Iteration: 1718; Percent complete: 43.0%; Average loss: 3.4575
Iteration: 1719; Percent complete: 43.0%; Average loss: 3.1275
Iteration: 1720; Percent complete: 43.0%; Average loss: 3.4173
Iteration: 1721; Percent complete: 43.0%; Average loss: 3.2492
Iteration: 1722; Percent complete: 43.0%; Average loss: 3.0550
Iteration: 1723; Percent complete: 43.1%; Average loss: 3.3876
Iteration: 1724; Percent complete: 43.1%; Average loss: 3.3123
Iteration: 1725; Percent complete: 43.1%; Average loss: 3.4845
Iteration: 1726; Percent complete: 43.1%; Average loss: 3.2483
Iteration: 1727; Percent complete: 43.2%; Average loss: 3.1099
Iteration: 1728; Percent complete: 43.2%; Average loss: 3.1958
Iteration: 1729; Percent complete: 43.2%; Average loss: 3.3868
Iteration: 1730; Percent complete: 43.2%; Average loss: 3.3371
Iteration: 1731; Percent complete: 43.3%; Average loss: 3.1662
Iteration: 1732; Percent complete: 43.3%; Average loss: 3.2189
Iteration: 1733; Percent complete: 43.3%; Average loss: 3.2030
Iteration: 1734; Percent complete: 43.4%; Average loss: 3.0984
Iteration: 1735; Percent complete: 43.4%; Average loss: 3.2244
Iteration: 1736; Percent complete: 43.4%; Average loss: 3.1392
Iteration: 1737; Percent complete: 43.4%; Average loss: 3.4301
Iteration: 1738; Percent complete: 43.5%; Average loss: 3.2785
Iteration: 1739; Percent complete: 43.5%; Average loss: 3.3364
Iteration: 1740; Percent complete: 43.5%; Average loss: 3.1598
Iteration: 1741; Percent complete: 43.5%; Average loss: 3.3873
Iteration: 1742; Percent complete: 43.5%; Average loss: 3.1770
Iteration: 1743; Percent complete: 43.6%; Average loss: 2.9848
Iteration: 1744; Percent complete: 43.6%; Average loss: 3.3659
Iteration: 1745; Percent complete: 43.6%; Average loss: 3.2957
Iteration: 1746; Percent complete: 43.6%; Average loss: 3.3747
Iteration: 1747; Percent complete: 43.7%; Average loss: 3.2969
Iteration: 1748; Percent complete: 43.7%; Average loss: 3.4268
Iteration: 1749; Percent complete: 43.7%; Average loss: 3.1791
Iteration: 1750; Percent complete: 43.8%; Average loss: 3.0516
Iteration: 1751; Percent complete: 43.8%; Average loss: 3.2961
Iteration: 1752; Percent complete: 43.8%; Average loss: 3.2149
Iteration: 1753; Percent complete: 43.8%; Average loss: 3.1372
Iteration: 1754; Percent complete: 43.9%; Average loss: 3.2806
Iteration: 1755; Percent complete: 43.9%; Average loss: 3.1149
Iteration: 1756; Percent complete: 43.9%; Average loss: 3.0168
Iteration: 1757; Percent complete: 43.9%; Average loss: 3.2021
Iteration: 1758; Percent complete: 44.0%; Average loss: 3.3987
Iteration: 1759; Percent complete: 44.0%; Average loss: 3.4150
Iteration: 1760; Percent complete: 44.0%; Average loss: 3.1338
Iteration: 1761; Percent complete: 44.0%; Average loss: 3.1382
Iteration: 1762; Percent complete: 44.0%; Average loss: 3.0634
Iteration: 1763; Percent complete: 44.1%; Average loss: 3.3069
Iteration: 1764; Percent complete: 44.1%; Average loss: 3.2759
Iteration: 1765; Percent complete: 44.1%; Average loss: 3.3183
Iteration: 1766; Percent complete: 44.1%; Average loss: 3.4282
Iteration: 1767; Percent complete: 44.2%; Average loss: 3.0970
Iteration: 1768; Percent complete: 44.2%; Average loss: 3.4659
Iteration: 1769; Percent complete: 44.2%; Average loss: 2.9854
Iteration: 1770; Percent complete: 44.2%; Average loss: 3.1708
Iteration: 1771; Percent complete: 44.3%; Average loss: 3.2474
Iteration: 1772; Percent complete: 44.3%; Average loss: 3.1298
Iteration: 1773; Percent complete: 44.3%; Average loss: 3.4287
Iteration: 1774; Percent complete: 44.4%; Average loss: 3.2740
Iteration: 1775; Percent complete: 44.4%; Average loss: 3.3764
Iteration: 1776; Percent complete: 44.4%; Average loss: 3.0526
Iteration: 1777; Percent complete: 44.4%; Average loss: 3.2083
Iteration: 1778; Percent complete: 44.5%; Average loss: 3.3750
Iteration: 1779; Percent complete: 44.5%; Average loss: 3.2298
Iteration: 1780; Percent complete: 44.5%; Average loss: 3.2455
Iteration: 1781; Percent complete: 44.5%; Average loss: 3.0444
Iteration: 1782; Percent complete: 44.5%; Average loss: 3.1597
Iteration: 1783; Percent complete: 44.6%; Average loss: 3.1202
Iteration: 1784; Percent complete: 44.6%; Average loss: 3.2416
Iteration: 1785; Percent complete: 44.6%; Average loss: 3.4608
Iteration: 1786; Percent complete: 44.6%; Average loss: 3.2505
Iteration: 1787; Percent complete: 44.7%; Average loss: 3.3043
Iteration: 1788; Percent complete: 44.7%; Average loss: 3.1881
Iteration: 1789; Percent complete: 44.7%; Average loss: 3.1991
Iteration: 1790; Percent complete: 44.8%; Average loss: 3.4092
Iteration: 1791; Percent complete: 44.8%; Average loss: 3.3208
Iteration: 1792; Percent complete: 44.8%; Average loss: 3.3859
Iteration: 1793; Percent complete: 44.8%; Average loss: 3.2657
Iteration: 1794; Percent complete: 44.9%; Average loss: 3.0973
Iteration: 1795; Percent complete: 44.9%; Average loss: 3.4249
Iteration: 1796; Percent complete: 44.9%; Average loss: 3.2910
Iteration: 1797; Percent complete: 44.9%; Average loss: 3.1436
Iteration: 1798; Percent complete: 45.0%; Average loss: 3.2479
Iteration: 1799; Percent complete: 45.0%; Average loss: 3.4878
Iteration: 1800; Percent complete: 45.0%; Average loss: 3.3723
Iteration: 1801; Percent complete: 45.0%; Average loss: 3.3549
Iteration: 1802; Percent complete: 45.1%; Average loss: 3.2235
Iteration: 1803; Percent complete: 45.1%; Average loss: 3.4145
Iteration: 1804; Percent complete: 45.1%; Average loss: 3.3409
Iteration: 1805; Percent complete: 45.1%; Average loss: 3.1238
Iteration: 1806; Percent complete: 45.1%; Average loss: 3.1587
Iteration: 1807; Percent complete: 45.2%; Average loss: 3.2888
Iteration: 1808; Percent complete: 45.2%; Average loss: 3.3441
Iteration: 1809; Percent complete: 45.2%; Average loss: 3.3750
Iteration: 1810; Percent complete: 45.2%; Average loss: 3.3661
Iteration: 1811; Percent complete: 45.3%; Average loss: 3.1167
Iteration: 1812; Percent complete: 45.3%; Average loss: 3.0820
Iteration: 1813; Percent complete: 45.3%; Average loss: 3.3455
Iteration: 1814; Percent complete: 45.4%; Average loss: 3.0896
Iteration: 1815; Percent complete: 45.4%; Average loss: 2.9216
Iteration: 1816; Percent complete: 45.4%; Average loss: 2.8834
Iteration: 1817; Percent complete: 45.4%; Average loss: 3.2017
Iteration: 1818; Percent complete: 45.5%; Average loss: 3.0412
Iteration: 1819; Percent complete: 45.5%; Average loss: 3.3980
Iteration: 1820; Percent complete: 45.5%; Average loss: 3.1793
Iteration: 1821; Percent complete: 45.5%; Average loss: 3.0879
Iteration: 1822; Percent complete: 45.6%; Average loss: 3.3330
Iteration: 1823; Percent complete: 45.6%; Average loss: 3.2749
Iteration: 1824; Percent complete: 45.6%; Average loss: 3.4934
Iteration: 1825; Percent complete: 45.6%; Average loss: 3.3195
Iteration: 1826; Percent complete: 45.6%; Average loss: 3.1911
Iteration: 1827; Percent complete: 45.7%; Average loss: 3.3396
Iteration: 1828; Percent complete: 45.7%; Average loss: 2.9826
Iteration: 1829; Percent complete: 45.7%; Average loss: 3.2715
Iteration: 1830; Percent complete: 45.8%; Average loss: 3.4938
Iteration: 1831; Percent complete: 45.8%; Average loss: 3.2368
Iteration: 1832; Percent complete: 45.8%; Average loss: 3.3075
Iteration: 1833; Percent complete: 45.8%; Average loss: 2.9794
Iteration: 1834; Percent complete: 45.9%; Average loss: 3.2073
Iteration: 1835; Percent complete: 45.9%; Average loss: 3.2587
Iteration: 1836; Percent complete: 45.9%; Average loss: 3.1587
Iteration: 1837; Percent complete: 45.9%; Average loss: 3.1994
Iteration: 1838; Percent complete: 46.0%; Average loss: 3.0875
Iteration: 1839; Percent complete: 46.0%; Average loss: 3.1562
Iteration: 1840; Percent complete: 46.0%; Average loss: 3.3386
Iteration: 1841; Percent complete: 46.0%; Average loss: 3.2229
Iteration: 1842; Percent complete: 46.1%; Average loss: 3.1605
Iteration: 1843; Percent complete: 46.1%; Average loss: 2.9079
Iteration: 1844; Percent complete: 46.1%; Average loss: 3.1633
Iteration: 1845; Percent complete: 46.1%; Average loss: 3.2485
Iteration: 1846; Percent complete: 46.2%; Average loss: 3.3117
Iteration: 1847; Percent complete: 46.2%; Average loss: 3.2428
Iteration: 1848; Percent complete: 46.2%; Average loss: 3.2076
Iteration: 1849; Percent complete: 46.2%; Average loss: 3.1984
Iteration: 1850; Percent complete: 46.2%; Average loss: 3.3028
Iteration: 1851; Percent complete: 46.3%; Average loss: 3.4454
Iteration: 1852; Percent complete: 46.3%; Average loss: 2.9997
Iteration: 1853; Percent complete: 46.3%; Average loss: 3.3039
Iteration: 1854; Percent complete: 46.4%; Average loss: 3.0957
Iteration: 1855; Percent complete: 46.4%; Average loss: 3.2233
Iteration: 1856; Percent complete: 46.4%; Average loss: 3.2724
Iteration: 1857; Percent complete: 46.4%; Average loss: 3.2863
Iteration: 1858; Percent complete: 46.5%; Average loss: 3.0209
Iteration: 1859; Percent complete: 46.5%; Average loss: 3.2815
Iteration: 1860; Percent complete: 46.5%; Average loss: 3.3002
Iteration: 1861; Percent complete: 46.5%; Average loss: 3.0746
Iteration: 1862; Percent complete: 46.6%; Average loss: 3.1330
Iteration: 1863; Percent complete: 46.6%; Average loss: 3.4328
Iteration: 1864; Percent complete: 46.6%; Average loss: 3.1041
Iteration: 1865; Percent complete: 46.6%; Average loss: 3.2493
Iteration: 1866; Percent complete: 46.7%; Average loss: 3.2346
Iteration: 1867; Percent complete: 46.7%; Average loss: 3.4029
Iteration: 1868; Percent complete: 46.7%; Average loss: 3.1508
Iteration: 1869; Percent complete: 46.7%; Average loss: 3.5951
Iteration: 1870; Percent complete: 46.8%; Average loss: 3.4345
Iteration: 1871; Percent complete: 46.8%; Average loss: 3.1843
Iteration: 1872; Percent complete: 46.8%; Average loss: 3.5081
Iteration: 1873; Percent complete: 46.8%; Average loss: 3.2471
Iteration: 1874; Percent complete: 46.9%; Average loss: 3.1523
Iteration: 1875; Percent complete: 46.9%; Average loss: 2.9681
Iteration: 1876; Percent complete: 46.9%; Average loss: 3.0408
Iteration: 1877; Percent complete: 46.9%; Average loss: 3.0435
Iteration: 1878; Percent complete: 46.9%; Average loss: 3.0746
Iteration: 1879; Percent complete: 47.0%; Average loss: 2.9636
Iteration: 1880; Percent complete: 47.0%; Average loss: 3.1038
Iteration: 1881; Percent complete: 47.0%; Average loss: 3.0852
Iteration: 1882; Percent complete: 47.0%; Average loss: 3.5179
Iteration: 1883; Percent complete: 47.1%; Average loss: 3.2835
Iteration: 1884; Percent complete: 47.1%; Average loss: 3.3519
Iteration: 1885; Percent complete: 47.1%; Average loss: 3.1597
Iteration: 1886; Percent complete: 47.1%; Average loss: 3.3107
Iteration: 1887; Percent complete: 47.2%; Average loss: 3.1160
Iteration: 1888; Percent complete: 47.2%; Average loss: 3.2746
Iteration: 1889; Percent complete: 47.2%; Average loss: 3.2551
Iteration: 1890; Percent complete: 47.2%; Average loss: 3.1362
Iteration: 1891; Percent complete: 47.3%; Average loss: 3.0653
Iteration: 1892; Percent complete: 47.3%; Average loss: 3.5032
Iteration: 1893; Percent complete: 47.3%; Average loss: 3.0425
Iteration: 1894; Percent complete: 47.3%; Average loss: 3.3845
Iteration: 1895; Percent complete: 47.4%; Average loss: 3.2381
Iteration: 1896; Percent complete: 47.4%; Average loss: 3.2925
Iteration: 1897; Percent complete: 47.4%; Average loss: 3.3145
Iteration: 1898; Percent complete: 47.4%; Average loss: 3.3453
Iteration: 1899; Percent complete: 47.5%; Average loss: 3.3653
Iteration: 1900; Percent complete: 47.5%; Average loss: 3.2791
Iteration: 1901; Percent complete: 47.5%; Average loss: 3.2669
Iteration: 1902; Percent complete: 47.5%; Average loss: 3.1862
Iteration: 1903; Percent complete: 47.6%; Average loss: 3.0774
Iteration: 1904; Percent complete: 47.6%; Average loss: 3.0051
Iteration: 1905; Percent complete: 47.6%; Average loss: 3.3581
Iteration: 1906; Percent complete: 47.6%; Average loss: 3.2552
Iteration: 1907; Percent complete: 47.7%; Average loss: 2.8993
Iteration: 1908; Percent complete: 47.7%; Average loss: 3.2220
Iteration: 1909; Percent complete: 47.7%; Average loss: 3.0106
Iteration: 1910; Percent complete: 47.8%; Average loss: 3.1499
Iteration: 1911; Percent complete: 47.8%; Average loss: 3.2871
Iteration: 1912; Percent complete: 47.8%; Average loss: 2.9950
Iteration: 1913; Percent complete: 47.8%; Average loss: 3.2649
Iteration: 1914; Percent complete: 47.9%; Average loss: 2.8153
Iteration: 1915; Percent complete: 47.9%; Average loss: 3.2544
Iteration: 1916; Percent complete: 47.9%; Average loss: 3.3114
Iteration: 1917; Percent complete: 47.9%; Average loss: 3.2247
Iteration: 1918; Percent complete: 47.9%; Average loss: 3.2909
Iteration: 1919; Percent complete: 48.0%; Average loss: 3.0077
Iteration: 1920; Percent complete: 48.0%; Average loss: 3.1889
Iteration: 1921; Percent complete: 48.0%; Average loss: 3.1286
Iteration: 1922; Percent complete: 48.0%; Average loss: 3.2218
Iteration: 1923; Percent complete: 48.1%; Average loss: 3.3170
Iteration: 1924; Percent complete: 48.1%; Average loss: 3.3255
Iteration: 1925; Percent complete: 48.1%; Average loss: 3.0756
Iteration: 1926; Percent complete: 48.1%; Average loss: 3.1218
Iteration: 1927; Percent complete: 48.2%; Average loss: 3.5538
Iteration: 1928; Percent complete: 48.2%; Average loss: 3.3536
Iteration: 1929; Percent complete: 48.2%; Average loss: 3.1950
Iteration: 1930; Percent complete: 48.2%; Average loss: 2.9121
Iteration: 1931; Percent complete: 48.3%; Average loss: 3.0930
Iteration: 1932; Percent complete: 48.3%; Average loss: 2.9553
Iteration: 1933; Percent complete: 48.3%; Average loss: 2.8942
Iteration: 1934; Percent complete: 48.4%; Average loss: 3.1622
Iteration: 1935; Percent complete: 48.4%; Average loss: 3.4662
Iteration: 1936; Percent complete: 48.4%; Average loss: 2.8989
Iteration: 1937; Percent complete: 48.4%; Average loss: 3.2283
Iteration: 1938; Percent complete: 48.4%; Average loss: 3.3906
Iteration: 1939; Percent complete: 48.5%; Average loss: 3.0799
Iteration: 1940; Percent complete: 48.5%; Average loss: 3.0265
Iteration: 1941; Percent complete: 48.5%; Average loss: 3.4172
Iteration: 1942; Percent complete: 48.5%; Average loss: 3.0221
Iteration: 1943; Percent complete: 48.6%; Average loss: 3.0819
Iteration: 1944; Percent complete: 48.6%; Average loss: 3.1054
Iteration: 1945; Percent complete: 48.6%; Average loss: 3.2042
Iteration: 1946; Percent complete: 48.6%; Average loss: 3.2081
Iteration: 1947; Percent complete: 48.7%; Average loss: 3.1590
Iteration: 1948; Percent complete: 48.7%; Average loss: 3.0387
Iteration: 1949; Percent complete: 48.7%; Average loss: 3.0099
Iteration: 1950; Percent complete: 48.8%; Average loss: 3.4728
Iteration: 1951; Percent complete: 48.8%; Average loss: 3.2343
Iteration: 1952; Percent complete: 48.8%; Average loss: 3.3277
Iteration: 1953; Percent complete: 48.8%; Average loss: 2.9752
Iteration: 1954; Percent complete: 48.9%; Average loss: 3.1808
Iteration: 1955; Percent complete: 48.9%; Average loss: 3.1940
Iteration: 1956; Percent complete: 48.9%; Average loss: 3.2655
Iteration: 1957; Percent complete: 48.9%; Average loss: 3.1010
Iteration: 1958; Percent complete: 48.9%; Average loss: 3.3653
Iteration: 1959; Percent complete: 49.0%; Average loss: 3.1345
Iteration: 1960; Percent complete: 49.0%; Average loss: 3.4017
Iteration: 1961; Percent complete: 49.0%; Average loss: 3.1981
Iteration: 1962; Percent complete: 49.0%; Average loss: 3.0401
Iteration: 1963; Percent complete: 49.1%; Average loss: 3.0874
Iteration: 1964; Percent complete: 49.1%; Average loss: 3.1709
Iteration: 1965; Percent complete: 49.1%; Average loss: 3.1604
Iteration: 1966; Percent complete: 49.1%; Average loss: 3.2921
Iteration: 1967; Percent complete: 49.2%; Average loss: 3.2320
Iteration: 1968; Percent complete: 49.2%; Average loss: 3.1821
Iteration: 1969; Percent complete: 49.2%; Average loss: 2.8709
Iteration: 1970; Percent complete: 49.2%; Average loss: 3.3198
Iteration: 1971; Percent complete: 49.3%; Average loss: 3.1995
Iteration: 1972; Percent complete: 49.3%; Average loss: 2.9485
Iteration: 1973; Percent complete: 49.3%; Average loss: 3.4757
Iteration: 1974; Percent complete: 49.4%; Average loss: 3.1409
Iteration: 1975; Percent complete: 49.4%; Average loss: 3.2528
Iteration: 1976; Percent complete: 49.4%; Average loss: 3.2611
Iteration: 1977; Percent complete: 49.4%; Average loss: 3.3623
Iteration: 1978; Percent complete: 49.5%; Average loss: 3.2792
Iteration: 1979; Percent complete: 49.5%; Average loss: 3.3723
Iteration: 1980; Percent complete: 49.5%; Average loss: 2.9383
Iteration: 1981; Percent complete: 49.5%; Average loss: 3.0315
Iteration: 1982; Percent complete: 49.5%; Average loss: 3.3744
Iteration: 1983; Percent complete: 49.6%; Average loss: 3.2237
Iteration: 1984; Percent complete: 49.6%; Average loss: 2.9598
Iteration: 1985; Percent complete: 49.6%; Average loss: 3.4145
Iteration: 1986; Percent complete: 49.6%; Average loss: 3.3868
Iteration: 1987; Percent complete: 49.7%; Average loss: 3.0175
Iteration: 1988; Percent complete: 49.7%; Average loss: 3.0990
Iteration: 1989; Percent complete: 49.7%; Average loss: 3.2277
Iteration: 1990; Percent complete: 49.8%; Average loss: 3.3626
Iteration: 1991; Percent complete: 49.8%; Average loss: 3.2111
Iteration: 1992; Percent complete: 49.8%; Average loss: 3.1981
Iteration: 1993; Percent complete: 49.8%; Average loss: 3.0601
Iteration: 1994; Percent complete: 49.9%; Average loss: 3.1962
Iteration: 1995; Percent complete: 49.9%; Average loss: 3.0122
Iteration: 1996; Percent complete: 49.9%; Average loss: 3.3717
Iteration: 1997; Percent complete: 49.9%; Average loss: 3.1767
Iteration: 1998; Percent complete: 50.0%; Average loss: 2.9408
Iteration: 1999; Percent complete: 50.0%; Average loss: 3.2029
Iteration: 2000; Percent complete: 50.0%; Average loss: 3.4771
Iteration: 2001; Percent complete: 50.0%; Average loss: 2.9703
Iteration: 2002; Percent complete: 50.0%; Average loss: 3.1014
Iteration: 2003; Percent complete: 50.1%; Average loss: 3.0378
Iteration: 2004; Percent complete: 50.1%; Average loss: 3.1028
Iteration: 2005; Percent complete: 50.1%; Average loss: 2.9996
Iteration: 2006; Percent complete: 50.1%; Average loss: 3.0143
Iteration: 2007; Percent complete: 50.2%; Average loss: 3.2945
Iteration: 2008; Percent complete: 50.2%; Average loss: 3.0514
Iteration: 2009; Percent complete: 50.2%; Average loss: 3.1741
Iteration: 2010; Percent complete: 50.2%; Average loss: 3.1802
Iteration: 2011; Percent complete: 50.3%; Average loss: 3.2616
Iteration: 2012; Percent complete: 50.3%; Average loss: 3.3539
Iteration: 2013; Percent complete: 50.3%; Average loss: 3.1327
Iteration: 2014; Percent complete: 50.3%; Average loss: 3.0895
Iteration: 2015; Percent complete: 50.4%; Average loss: 3.3156
Iteration: 2016; Percent complete: 50.4%; Average loss: 3.2284
Iteration: 2017; Percent complete: 50.4%; Average loss: 3.1199
Iteration: 2018; Percent complete: 50.4%; Average loss: 3.2066
Iteration: 2019; Percent complete: 50.5%; Average loss: 3.2635
Iteration: 2020; Percent complete: 50.5%; Average loss: 3.2273
Iteration: 2021; Percent complete: 50.5%; Average loss: 3.3048
Iteration: 2022; Percent complete: 50.5%; Average loss: 3.2025
Iteration: 2023; Percent complete: 50.6%; Average loss: 3.2088
Iteration: 2024; Percent complete: 50.6%; Average loss: 3.1132
Iteration: 2025; Percent complete: 50.6%; Average loss: 3.2974
Iteration: 2026; Percent complete: 50.6%; Average loss: 3.3083
Iteration: 2027; Percent complete: 50.7%; Average loss: 3.1707
Iteration: 2028; Percent complete: 50.7%; Average loss: 3.1566
Iteration: 2029; Percent complete: 50.7%; Average loss: 2.8075
Iteration: 2030; Percent complete: 50.7%; Average loss: 3.2871
Iteration: 2031; Percent complete: 50.8%; Average loss: 3.3159
Iteration: 2032; Percent complete: 50.8%; Average loss: 3.0411
Iteration: 2033; Percent complete: 50.8%; Average loss: 3.0837
Iteration: 2034; Percent complete: 50.8%; Average loss: 3.1893
Iteration: 2035; Percent complete: 50.9%; Average loss: 3.1371
Iteration: 2036; Percent complete: 50.9%; Average loss: 2.9922
Iteration: 2037; Percent complete: 50.9%; Average loss: 3.1371
Iteration: 2038; Percent complete: 50.9%; Average loss: 3.0886
Iteration: 2039; Percent complete: 51.0%; Average loss: 3.0629
Iteration: 2040; Percent complete: 51.0%; Average loss: 3.0897
Iteration: 2041; Percent complete: 51.0%; Average loss: 3.2966
Iteration: 2042; Percent complete: 51.0%; Average loss: 3.0920
Iteration: 2043; Percent complete: 51.1%; Average loss: 3.0098
Iteration: 2044; Percent complete: 51.1%; Average loss: 3.4273
Iteration: 2045; Percent complete: 51.1%; Average loss: 2.8220
Iteration: 2046; Percent complete: 51.1%; Average loss: 3.2160
Iteration: 2047; Percent complete: 51.2%; Average loss: 2.9292
Iteration: 2048; Percent complete: 51.2%; Average loss: 3.0929
Iteration: 2049; Percent complete: 51.2%; Average loss: 3.1098
Iteration: 2050; Percent complete: 51.2%; Average loss: 3.1185
Iteration: 2051; Percent complete: 51.3%; Average loss: 3.3391
Iteration: 2052; Percent complete: 51.3%; Average loss: 3.2251
Iteration: 2053; Percent complete: 51.3%; Average loss: 3.3000
Iteration: 2054; Percent complete: 51.3%; Average loss: 3.2893
Iteration: 2055; Percent complete: 51.4%; Average loss: 3.3353
Iteration: 2056; Percent complete: 51.4%; Average loss: 3.0292
Iteration: 2057; Percent complete: 51.4%; Average loss: 3.2972
Iteration: 2058; Percent complete: 51.4%; Average loss: 3.2627
Iteration: 2059; Percent complete: 51.5%; Average loss: 3.3296
Iteration: 2060; Percent complete: 51.5%; Average loss: 3.0281
Iteration: 2061; Percent complete: 51.5%; Average loss: 3.0973
Iteration: 2062; Percent complete: 51.5%; Average loss: 3.2851
Iteration: 2063; Percent complete: 51.6%; Average loss: 3.4965
Iteration: 2064; Percent complete: 51.6%; Average loss: 3.1749
Iteration: 2065; Percent complete: 51.6%; Average loss: 3.1800
Iteration: 2066; Percent complete: 51.6%; Average loss: 3.2403
Iteration: 2067; Percent complete: 51.7%; Average loss: 2.9761
Iteration: 2068; Percent complete: 51.7%; Average loss: 3.1486
Iteration: 2069; Percent complete: 51.7%; Average loss: 3.1467
Iteration: 2070; Percent complete: 51.7%; Average loss: 3.3618
Iteration: 2071; Percent complete: 51.8%; Average loss: 3.1573
Iteration: 2072; Percent complete: 51.8%; Average loss: 2.9820
Iteration: 2073; Percent complete: 51.8%; Average loss: 2.8741
Iteration: 2074; Percent complete: 51.8%; Average loss: 3.1692
Iteration: 2075; Percent complete: 51.9%; Average loss: 3.1877
Iteration: 2076; Percent complete: 51.9%; Average loss: 3.0265
Iteration: 2077; Percent complete: 51.9%; Average loss: 3.1128
Iteration: 2078; Percent complete: 51.9%; Average loss: 2.9378
Iteration: 2079; Percent complete: 52.0%; Average loss: 3.5882
Iteration: 2080; Percent complete: 52.0%; Average loss: 3.1344
Iteration: 2081; Percent complete: 52.0%; Average loss: 3.1256
Iteration: 2082; Percent complete: 52.0%; Average loss: 3.1903
Iteration: 2083; Percent complete: 52.1%; Average loss: 2.9721
Iteration: 2084; Percent complete: 52.1%; Average loss: 3.2661
Iteration: 2085; Percent complete: 52.1%; Average loss: 3.0846
Iteration: 2086; Percent complete: 52.1%; Average loss: 3.2080
Iteration: 2087; Percent complete: 52.2%; Average loss: 3.2526
Iteration: 2088; Percent complete: 52.2%; Average loss: 3.0639
Iteration: 2089; Percent complete: 52.2%; Average loss: 3.1337
Iteration: 2090; Percent complete: 52.2%; Average loss: 3.0356
Iteration: 2091; Percent complete: 52.3%; Average loss: 3.1324
Iteration: 2092; Percent complete: 52.3%; Average loss: 3.1576
Iteration: 2093; Percent complete: 52.3%; Average loss: 2.9393
Iteration: 2094; Percent complete: 52.3%; Average loss: 3.3254
Iteration: 2095; Percent complete: 52.4%; Average loss: 3.0303
Iteration: 2096; Percent complete: 52.4%; Average loss: 3.2472
Iteration: 2097; Percent complete: 52.4%; Average loss: 3.2032
Iteration: 2098; Percent complete: 52.4%; Average loss: 3.2246
Iteration: 2099; Percent complete: 52.5%; Average loss: 3.3015
Iteration: 2100; Percent complete: 52.5%; Average loss: 3.2167
Iteration: 2101; Percent complete: 52.5%; Average loss: 3.4351
Iteration: 2102; Percent complete: 52.5%; Average loss: 3.2959
Iteration: 2103; Percent complete: 52.6%; Average loss: 3.1491
Iteration: 2104; Percent complete: 52.6%; Average loss: 3.2149
Iteration: 2105; Percent complete: 52.6%; Average loss: 3.2206
Iteration: 2106; Percent complete: 52.6%; Average loss: 3.4582
Iteration: 2107; Percent complete: 52.7%; Average loss: 3.2691
Iteration: 2108; Percent complete: 52.7%; Average loss: 3.1680
Iteration: 2109; Percent complete: 52.7%; Average loss: 3.1150
Iteration: 2110; Percent complete: 52.8%; Average loss: 3.0858
Iteration: 2111; Percent complete: 52.8%; Average loss: 3.0227
Iteration: 2112; Percent complete: 52.8%; Average loss: 3.1610
Iteration: 2113; Percent complete: 52.8%; Average loss: 3.0575
Iteration: 2114; Percent complete: 52.8%; Average loss: 2.8186
Iteration: 2115; Percent complete: 52.9%; Average loss: 3.2203
Iteration: 2116; Percent complete: 52.9%; Average loss: 3.1497
Iteration: 2117; Percent complete: 52.9%; Average loss: 3.0867
Iteration: 2118; Percent complete: 52.9%; Average loss: 3.1516
Iteration: 2119; Percent complete: 53.0%; Average loss: 3.2102
Iteration: 2120; Percent complete: 53.0%; Average loss: 2.8978
Iteration: 2121; Percent complete: 53.0%; Average loss: 3.1061
Iteration: 2122; Percent complete: 53.0%; Average loss: 3.2581
Iteration: 2123; Percent complete: 53.1%; Average loss: 3.0244
Iteration: 2124; Percent complete: 53.1%; Average loss: 3.0028
Iteration: 2125; Percent complete: 53.1%; Average loss: 2.9935
Iteration: 2126; Percent complete: 53.1%; Average loss: 3.3329
Iteration: 2127; Percent complete: 53.2%; Average loss: 3.3074
Iteration: 2128; Percent complete: 53.2%; Average loss: 2.9700
Iteration: 2129; Percent complete: 53.2%; Average loss: 3.1590
Iteration: 2130; Percent complete: 53.2%; Average loss: 3.3045
Iteration: 2131; Percent complete: 53.3%; Average loss: 3.3115
Iteration: 2132; Percent complete: 53.3%; Average loss: 3.1076
Iteration: 2133; Percent complete: 53.3%; Average loss: 2.9731
Iteration: 2134; Percent complete: 53.3%; Average loss: 3.0866
Iteration: 2135; Percent complete: 53.4%; Average loss: 3.1194
Iteration: 2136; Percent complete: 53.4%; Average loss: 3.2794
Iteration: 2137; Percent complete: 53.4%; Average loss: 2.8238
Iteration: 2138; Percent complete: 53.4%; Average loss: 3.1432
Iteration: 2139; Percent complete: 53.5%; Average loss: 3.0698
Iteration: 2140; Percent complete: 53.5%; Average loss: 3.3350
Iteration: 2141; Percent complete: 53.5%; Average loss: 3.2455
Iteration: 2142; Percent complete: 53.5%; Average loss: 3.0628
Iteration: 2143; Percent complete: 53.6%; Average loss: 3.3587
Iteration: 2144; Percent complete: 53.6%; Average loss: 3.0310
Iteration: 2145; Percent complete: 53.6%; Average loss: 3.1873
Iteration: 2146; Percent complete: 53.6%; Average loss: 3.2904
Iteration: 2147; Percent complete: 53.7%; Average loss: 3.1257
Iteration: 2148; Percent complete: 53.7%; Average loss: 2.9913
Iteration: 2149; Percent complete: 53.7%; Average loss: 3.2936
Iteration: 2150; Percent complete: 53.8%; Average loss: 3.0928
Iteration: 2151; Percent complete: 53.8%; Average loss: 3.2371
Iteration: 2152; Percent complete: 53.8%; Average loss: 2.9719
Iteration: 2153; Percent complete: 53.8%; Average loss: 2.9951
Iteration: 2154; Percent complete: 53.8%; Average loss: 3.2986
Iteration: 2155; Percent complete: 53.9%; Average loss: 3.0373
Iteration: 2156; Percent complete: 53.9%; Average loss: 3.1005
Iteration: 2157; Percent complete: 53.9%; Average loss: 2.9968
Iteration: 2158; Percent complete: 53.9%; Average loss: 3.2171
Iteration: 2159; Percent complete: 54.0%; Average loss: 3.1027
Iteration: 2160; Percent complete: 54.0%; Average loss: 3.4094
Iteration: 2161; Percent complete: 54.0%; Average loss: 3.1325
Iteration: 2162; Percent complete: 54.0%; Average loss: 3.2273
Iteration: 2163; Percent complete: 54.1%; Average loss: 3.1797
Iteration: 2164; Percent complete: 54.1%; Average loss: 3.1281
Iteration: 2165; Percent complete: 54.1%; Average loss: 3.0982
Iteration: 2166; Percent complete: 54.1%; Average loss: 3.0935
Iteration: 2167; Percent complete: 54.2%; Average loss: 3.0435
Iteration: 2168; Percent complete: 54.2%; Average loss: 3.1399
Iteration: 2169; Percent complete: 54.2%; Average loss: 3.0437
Iteration: 2170; Percent complete: 54.2%; Average loss: 3.1246
Iteration: 2171; Percent complete: 54.3%; Average loss: 2.9988
Iteration: 2172; Percent complete: 54.3%; Average loss: 3.2582
Iteration: 2173; Percent complete: 54.3%; Average loss: 3.2768
Iteration: 2174; Percent complete: 54.4%; Average loss: 3.1605
Iteration: 2175; Percent complete: 54.4%; Average loss: 2.9353
Iteration: 2176; Percent complete: 54.4%; Average loss: 3.0262
Iteration: 2177; Percent complete: 54.4%; Average loss: 3.2103
Iteration: 2178; Percent complete: 54.4%; Average loss: 3.2363
Iteration: 2179; Percent complete: 54.5%; Average loss: 3.2640
Iteration: 2180; Percent complete: 54.5%; Average loss: 3.3563
Iteration: 2181; Percent complete: 54.5%; Average loss: 3.1576
Iteration: 2182; Percent complete: 54.5%; Average loss: 2.8566
Iteration: 2183; Percent complete: 54.6%; Average loss: 3.1237
Iteration: 2184; Percent complete: 54.6%; Average loss: 2.9925
Iteration: 2185; Percent complete: 54.6%; Average loss: 2.9886
Iteration: 2186; Percent complete: 54.6%; Average loss: 3.1638
Iteration: 2187; Percent complete: 54.7%; Average loss: 3.1621
Iteration: 2188; Percent complete: 54.7%; Average loss: 3.0129
Iteration: 2189; Percent complete: 54.7%; Average loss: 3.1444
Iteration: 2190; Percent complete: 54.8%; Average loss: 3.3305
Iteration: 2191; Percent complete: 54.8%; Average loss: 3.0935
Iteration: 2192; Percent complete: 54.8%; Average loss: 3.2539
Iteration: 2193; Percent complete: 54.8%; Average loss: 3.1728
Iteration: 2194; Percent complete: 54.9%; Average loss: 3.1372
Iteration: 2195; Percent complete: 54.9%; Average loss: 3.0687
Iteration: 2196; Percent complete: 54.9%; Average loss: 3.0813
Iteration: 2197; Percent complete: 54.9%; Average loss: 3.0452
Iteration: 2198; Percent complete: 54.9%; Average loss: 3.1226
Iteration: 2199; Percent complete: 55.0%; Average loss: 3.1232
Iteration: 2200; Percent complete: 55.0%; Average loss: 3.1667
Iteration: 2201; Percent complete: 55.0%; Average loss: 3.3582
Iteration: 2202; Percent complete: 55.0%; Average loss: 3.3855
Iteration: 2203; Percent complete: 55.1%; Average loss: 3.0015
Iteration: 2204; Percent complete: 55.1%; Average loss: 3.3482
Iteration: 2205; Percent complete: 55.1%; Average loss: 3.0761
Iteration: 2206; Percent complete: 55.1%; Average loss: 3.1421
Iteration: 2207; Percent complete: 55.2%; Average loss: 3.1217
Iteration: 2208; Percent complete: 55.2%; Average loss: 2.7519
Iteration: 2209; Percent complete: 55.2%; Average loss: 3.2151
Iteration: 2210; Percent complete: 55.2%; Average loss: 3.0189
Iteration: 2211; Percent complete: 55.3%; Average loss: 3.4182
Iteration: 2212; Percent complete: 55.3%; Average loss: 3.0763
Iteration: 2213; Percent complete: 55.3%; Average loss: 3.2832
Iteration: 2214; Percent complete: 55.4%; Average loss: 3.0460
Iteration: 2215; Percent complete: 55.4%; Average loss: 2.9588
Iteration: 2216; Percent complete: 55.4%; Average loss: 3.3659
Iteration: 2217; Percent complete: 55.4%; Average loss: 3.3296
Iteration: 2218; Percent complete: 55.5%; Average loss: 2.9111
Iteration: 2219; Percent complete: 55.5%; Average loss: 3.2251
Iteration: 2220; Percent complete: 55.5%; Average loss: 3.1091
Iteration: 2221; Percent complete: 55.5%; Average loss: 3.1284
Iteration: 2222; Percent complete: 55.5%; Average loss: 3.0732
Iteration: 2223; Percent complete: 55.6%; Average loss: 3.2976
Iteration: 2224; Percent complete: 55.6%; Average loss: 3.0730
Iteration: 2225; Percent complete: 55.6%; Average loss: 3.2438
Iteration: 2226; Percent complete: 55.6%; Average loss: 3.1635
Iteration: 2227; Percent complete: 55.7%; Average loss: 3.1576
Iteration: 2228; Percent complete: 55.7%; Average loss: 3.1197
Iteration: 2229; Percent complete: 55.7%; Average loss: 3.0408
Iteration: 2230; Percent complete: 55.8%; Average loss: 2.7886
Iteration: 2231; Percent complete: 55.8%; Average loss: 3.2454
Iteration: 2232; Percent complete: 55.8%; Average loss: 2.9413
Iteration: 2233; Percent complete: 55.8%; Average loss: 3.0820
Iteration: 2234; Percent complete: 55.9%; Average loss: 2.7978
Iteration: 2235; Percent complete: 55.9%; Average loss: 2.9999
Iteration: 2236; Percent complete: 55.9%; Average loss: 3.1166
Iteration: 2237; Percent complete: 55.9%; Average loss: 3.0404
Iteration: 2238; Percent complete: 56.0%; Average loss: 2.9624
Iteration: 2239; Percent complete: 56.0%; Average loss: 3.1043
Iteration: 2240; Percent complete: 56.0%; Average loss: 2.9540
Iteration: 2241; Percent complete: 56.0%; Average loss: 3.2017
Iteration: 2242; Percent complete: 56.0%; Average loss: 3.0611
Iteration: 2243; Percent complete: 56.1%; Average loss: 3.1522
Iteration: 2244; Percent complete: 56.1%; Average loss: 2.9874
Iteration: 2245; Percent complete: 56.1%; Average loss: 2.9305
Iteration: 2246; Percent complete: 56.1%; Average loss: 3.0631
Iteration: 2247; Percent complete: 56.2%; Average loss: 3.1466
Iteration: 2248; Percent complete: 56.2%; Average loss: 3.3071
Iteration: 2249; Percent complete: 56.2%; Average loss: 3.0966
Iteration: 2250; Percent complete: 56.2%; Average loss: 3.0033
Iteration: 2251; Percent complete: 56.3%; Average loss: 3.2929
Iteration: 2252; Percent complete: 56.3%; Average loss: 3.0226
Iteration: 2253; Percent complete: 56.3%; Average loss: 3.0580
Iteration: 2254; Percent complete: 56.4%; Average loss: 3.0538
Iteration: 2255; Percent complete: 56.4%; Average loss: 3.0463
Iteration: 2256; Percent complete: 56.4%; Average loss: 3.1624
Iteration: 2257; Percent complete: 56.4%; Average loss: 3.0952
Iteration: 2258; Percent complete: 56.5%; Average loss: 3.5248
Iteration: 2259; Percent complete: 56.5%; Average loss: 3.0940
Iteration: 2260; Percent complete: 56.5%; Average loss: 3.3911
Iteration: 2261; Percent complete: 56.5%; Average loss: 3.0700
Iteration: 2262; Percent complete: 56.5%; Average loss: 3.1066
Iteration: 2263; Percent complete: 56.6%; Average loss: 3.1284
Iteration: 2264; Percent complete: 56.6%; Average loss: 2.8777
Iteration: 2265; Percent complete: 56.6%; Average loss: 2.8171
Iteration: 2266; Percent complete: 56.6%; Average loss: 3.1899
Iteration: 2267; Percent complete: 56.7%; Average loss: 2.9895
Iteration: 2268; Percent complete: 56.7%; Average loss: 3.2125
Iteration: 2269; Percent complete: 56.7%; Average loss: 2.9589
Iteration: 2270; Percent complete: 56.8%; Average loss: 2.9405
Iteration: 2271; Percent complete: 56.8%; Average loss: 3.2102
Iteration: 2272; Percent complete: 56.8%; Average loss: 3.1648
Iteration: 2273; Percent complete: 56.8%; Average loss: 2.9770
Iteration: 2274; Percent complete: 56.9%; Average loss: 3.1613
Iteration: 2275; Percent complete: 56.9%; Average loss: 2.8365
Iteration: 2276; Percent complete: 56.9%; Average loss: 3.0006
Iteration: 2277; Percent complete: 56.9%; Average loss: 3.0835
Iteration: 2278; Percent complete: 57.0%; Average loss: 3.2716
Iteration: 2279; Percent complete: 57.0%; Average loss: 2.8290
Iteration: 2280; Percent complete: 57.0%; Average loss: 3.0572
Iteration: 2281; Percent complete: 57.0%; Average loss: 3.1280
Iteration: 2282; Percent complete: 57.0%; Average loss: 3.0159
Iteration: 2283; Percent complete: 57.1%; Average loss: 3.0549
Iteration: 2284; Percent complete: 57.1%; Average loss: 3.0263
Iteration: 2285; Percent complete: 57.1%; Average loss: 2.9163
Iteration: 2286; Percent complete: 57.1%; Average loss: 2.8828
Iteration: 2287; Percent complete: 57.2%; Average loss: 2.9199
Iteration: 2288; Percent complete: 57.2%; Average loss: 3.0614
Iteration: 2289; Percent complete: 57.2%; Average loss: 3.0427
Iteration: 2290; Percent complete: 57.2%; Average loss: 3.0417
Iteration: 2291; Percent complete: 57.3%; Average loss: 3.1260
Iteration: 2292; Percent complete: 57.3%; Average loss: 3.0672
Iteration: 2293; Percent complete: 57.3%; Average loss: 3.3177
Iteration: 2294; Percent complete: 57.4%; Average loss: 3.1953
Iteration: 2295; Percent complete: 57.4%; Average loss: 3.0258
Iteration: 2296; Percent complete: 57.4%; Average loss: 3.2208
Iteration: 2297; Percent complete: 57.4%; Average loss: 3.2106
Iteration: 2298; Percent complete: 57.5%; Average loss: 3.0210
Iteration: 2299; Percent complete: 57.5%; Average loss: 3.0100
Iteration: 2300; Percent complete: 57.5%; Average loss: 2.9274
Iteration: 2301; Percent complete: 57.5%; Average loss: 3.1166
Iteration: 2302; Percent complete: 57.6%; Average loss: 3.1066
Iteration: 2303; Percent complete: 57.6%; Average loss: 2.9517
Iteration: 2304; Percent complete: 57.6%; Average loss: 3.3133
Iteration: 2305; Percent complete: 57.6%; Average loss: 3.0385
Iteration: 2306; Percent complete: 57.6%; Average loss: 3.4169
Iteration: 2307; Percent complete: 57.7%; Average loss: 3.1341
Iteration: 2308; Percent complete: 57.7%; Average loss: 2.8023
Iteration: 2309; Percent complete: 57.7%; Average loss: 3.1704
Iteration: 2310; Percent complete: 57.8%; Average loss: 3.1326
Iteration: 2311; Percent complete: 57.8%; Average loss: 2.9780
Iteration: 2312; Percent complete: 57.8%; Average loss: 2.8605
Iteration: 2313; Percent complete: 57.8%; Average loss: 3.1871
Iteration: 2314; Percent complete: 57.9%; Average loss: 2.8505
Iteration: 2315; Percent complete: 57.9%; Average loss: 2.9599
Iteration: 2316; Percent complete: 57.9%; Average loss: 3.0769
Iteration: 2317; Percent complete: 57.9%; Average loss: 3.0423
Iteration: 2318; Percent complete: 58.0%; Average loss: 3.2507
Iteration: 2319; Percent complete: 58.0%; Average loss: 3.0434
Iteration: 2320; Percent complete: 58.0%; Average loss: 3.1291
Iteration: 2321; Percent complete: 58.0%; Average loss: 3.2998
Iteration: 2322; Percent complete: 58.1%; Average loss: 3.1642
Iteration: 2323; Percent complete: 58.1%; Average loss: 3.0737
Iteration: 2324; Percent complete: 58.1%; Average loss: 2.8840
Iteration: 2325; Percent complete: 58.1%; Average loss: 3.1348
Iteration: 2326; Percent complete: 58.1%; Average loss: 2.9274
Iteration: 2327; Percent complete: 58.2%; Average loss: 3.0497
Iteration: 2328; Percent complete: 58.2%; Average loss: 3.2646
Iteration: 2329; Percent complete: 58.2%; Average loss: 3.4050
Iteration: 2330; Percent complete: 58.2%; Average loss: 3.0114
Iteration: 2331; Percent complete: 58.3%; Average loss: 3.1647
Iteration: 2332; Percent complete: 58.3%; Average loss: 3.1285
Iteration: 2333; Percent complete: 58.3%; Average loss: 2.9274
Iteration: 2334; Percent complete: 58.4%; Average loss: 3.2877
Iteration: 2335; Percent complete: 58.4%; Average loss: 3.0933
Iteration: 2336; Percent complete: 58.4%; Average loss: 2.8557
Iteration: 2337; Percent complete: 58.4%; Average loss: 2.8981
Iteration: 2338; Percent complete: 58.5%; Average loss: 2.9606
Iteration: 2339; Percent complete: 58.5%; Average loss: 2.9990
Iteration: 2340; Percent complete: 58.5%; Average loss: 3.3345
Iteration: 2341; Percent complete: 58.5%; Average loss: 3.1101
Iteration: 2342; Percent complete: 58.6%; Average loss: 3.0855
Iteration: 2343; Percent complete: 58.6%; Average loss: 2.7271
Iteration: 2344; Percent complete: 58.6%; Average loss: 3.0179
Iteration: 2345; Percent complete: 58.6%; Average loss: 3.0945
Iteration: 2346; Percent complete: 58.7%; Average loss: 2.9645
Iteration: 2347; Percent complete: 58.7%; Average loss: 3.1275
Iteration: 2348; Percent complete: 58.7%; Average loss: 3.1865
Iteration: 2349; Percent complete: 58.7%; Average loss: 3.1949
Iteration: 2350; Percent complete: 58.8%; Average loss: 3.2166
Iteration: 2351; Percent complete: 58.8%; Average loss: 3.1470
Iteration: 2352; Percent complete: 58.8%; Average loss: 3.0204
Iteration: 2353; Percent complete: 58.8%; Average loss: 2.9040
Iteration: 2354; Percent complete: 58.9%; Average loss: 2.9691
Iteration: 2355; Percent complete: 58.9%; Average loss: 3.0640
Iteration: 2356; Percent complete: 58.9%; Average loss: 2.9755
Iteration: 2357; Percent complete: 58.9%; Average loss: 3.0337
Iteration: 2358; Percent complete: 59.0%; Average loss: 2.9590
Iteration: 2359; Percent complete: 59.0%; Average loss: 3.2784
Iteration: 2360; Percent complete: 59.0%; Average loss: 2.8630
Iteration: 2361; Percent complete: 59.0%; Average loss: 3.0202
Iteration: 2362; Percent complete: 59.1%; Average loss: 3.1903
Iteration: 2363; Percent complete: 59.1%; Average loss: 3.0071
Iteration: 2364; Percent complete: 59.1%; Average loss: 2.7034
Iteration: 2365; Percent complete: 59.1%; Average loss: 3.1839
Iteration: 2366; Percent complete: 59.2%; Average loss: 2.8000
Iteration: 2367; Percent complete: 59.2%; Average loss: 3.1982
Iteration: 2368; Percent complete: 59.2%; Average loss: 3.1759
Iteration: 2369; Percent complete: 59.2%; Average loss: 2.9719
Iteration: 2370; Percent complete: 59.2%; Average loss: 3.0363
Iteration: 2371; Percent complete: 59.3%; Average loss: 3.2675
Iteration: 2372; Percent complete: 59.3%; Average loss: 3.1691
Iteration: 2373; Percent complete: 59.3%; Average loss: 3.0819
Iteration: 2374; Percent complete: 59.4%; Average loss: 3.0833
Iteration: 2375; Percent complete: 59.4%; Average loss: 3.1767
Iteration: 2376; Percent complete: 59.4%; Average loss: 2.9642
Iteration: 2377; Percent complete: 59.4%; Average loss: 3.0969
Iteration: 2378; Percent complete: 59.5%; Average loss: 2.9414
Iteration: 2379; Percent complete: 59.5%; Average loss: 2.8396
Iteration: 2380; Percent complete: 59.5%; Average loss: 3.1502
Iteration: 2381; Percent complete: 59.5%; Average loss: 2.9882
Iteration: 2382; Percent complete: 59.6%; Average loss: 3.1441
Iteration: 2383; Percent complete: 59.6%; Average loss: 3.0517
Iteration: 2384; Percent complete: 59.6%; Average loss: 3.3997
Iteration: 2385; Percent complete: 59.6%; Average loss: 2.9364
Iteration: 2386; Percent complete: 59.7%; Average loss: 2.9539
Iteration: 2387; Percent complete: 59.7%; Average loss: 3.4516
Iteration: 2388; Percent complete: 59.7%; Average loss: 2.8981
Iteration: 2389; Percent complete: 59.7%; Average loss: 3.1752
Iteration: 2390; Percent complete: 59.8%; Average loss: 2.7300
Iteration: 2391; Percent complete: 59.8%; Average loss: 2.8924
Iteration: 2392; Percent complete: 59.8%; Average loss: 3.2384
Iteration: 2393; Percent complete: 59.8%; Average loss: 2.8062
Iteration: 2394; Percent complete: 59.9%; Average loss: 3.0206
Iteration: 2395; Percent complete: 59.9%; Average loss: 3.0160
Iteration: 2396; Percent complete: 59.9%; Average loss: 2.9453
Iteration: 2397; Percent complete: 59.9%; Average loss: 2.9353
Iteration: 2398; Percent complete: 60.0%; Average loss: 3.3719
Iteration: 2399; Percent complete: 60.0%; Average loss: 3.1893
Iteration: 2400; Percent complete: 60.0%; Average loss: 3.1417
Iteration: 2401; Percent complete: 60.0%; Average loss: 3.2299
Iteration: 2402; Percent complete: 60.1%; Average loss: 3.0825
Iteration: 2403; Percent complete: 60.1%; Average loss: 3.0203
Iteration: 2404; Percent complete: 60.1%; Average loss: 3.1720
Iteration: 2405; Percent complete: 60.1%; Average loss: 3.0473
Iteration: 2406; Percent complete: 60.2%; Average loss: 3.0055
Iteration: 2407; Percent complete: 60.2%; Average loss: 3.1607
Iteration: 2408; Percent complete: 60.2%; Average loss: 3.0612
Iteration: 2409; Percent complete: 60.2%; Average loss: 3.1018
Iteration: 2410; Percent complete: 60.2%; Average loss: 3.1882
Iteration: 2411; Percent complete: 60.3%; Average loss: 3.0783
Iteration: 2412; Percent complete: 60.3%; Average loss: 3.0412
Iteration: 2413; Percent complete: 60.3%; Average loss: 3.2311
Iteration: 2414; Percent complete: 60.4%; Average loss: 2.9264
Iteration: 2415; Percent complete: 60.4%; Average loss: 3.2547
Iteration: 2416; Percent complete: 60.4%; Average loss: 3.1910
Iteration: 2417; Percent complete: 60.4%; Average loss: 2.9467
Iteration: 2418; Percent complete: 60.5%; Average loss: 3.3528
Iteration: 2419; Percent complete: 60.5%; Average loss: 2.9949
Iteration: 2420; Percent complete: 60.5%; Average loss: 3.0495
Iteration: 2421; Percent complete: 60.5%; Average loss: 3.1296
Iteration: 2422; Percent complete: 60.6%; Average loss: 3.1428
Iteration: 2423; Percent complete: 60.6%; Average loss: 3.0691
Iteration: 2424; Percent complete: 60.6%; Average loss: 3.0753
Iteration: 2425; Percent complete: 60.6%; Average loss: 2.9678
Iteration: 2426; Percent complete: 60.7%; Average loss: 2.9821
Iteration: 2427; Percent complete: 60.7%; Average loss: 3.0337
Iteration: 2428; Percent complete: 60.7%; Average loss: 3.4116
Iteration: 2429; Percent complete: 60.7%; Average loss: 3.2455
Iteration: 2430; Percent complete: 60.8%; Average loss: 3.3810
Iteration: 2431; Percent complete: 60.8%; Average loss: 3.0216
Iteration: 2432; Percent complete: 60.8%; Average loss: 2.9766
Iteration: 2433; Percent complete: 60.8%; Average loss: 2.7995
Iteration: 2434; Percent complete: 60.9%; Average loss: 2.9254
Iteration: 2435; Percent complete: 60.9%; Average loss: 3.2288
Iteration: 2436; Percent complete: 60.9%; Average loss: 3.1635
Iteration: 2437; Percent complete: 60.9%; Average loss: 2.9620
Iteration: 2438; Percent complete: 61.0%; Average loss: 3.4039
Iteration: 2439; Percent complete: 61.0%; Average loss: 3.2450
Iteration: 2440; Percent complete: 61.0%; Average loss: 2.9832
Iteration: 2441; Percent complete: 61.0%; Average loss: 3.2590
Iteration: 2442; Percent complete: 61.1%; Average loss: 2.9701
Iteration: 2443; Percent complete: 61.1%; Average loss: 2.9415
Iteration: 2444; Percent complete: 61.1%; Average loss: 2.8293
Iteration: 2445; Percent complete: 61.1%; Average loss: 3.0035
Iteration: 2446; Percent complete: 61.2%; Average loss: 2.9528
Iteration: 2447; Percent complete: 61.2%; Average loss: 2.9211
Iteration: 2448; Percent complete: 61.2%; Average loss: 3.1714
Iteration: 2449; Percent complete: 61.2%; Average loss: 3.0484
Iteration: 2450; Percent complete: 61.3%; Average loss: 3.2017
Iteration: 2451; Percent complete: 61.3%; Average loss: 3.0221
Iteration: 2452; Percent complete: 61.3%; Average loss: 2.9607
Iteration: 2453; Percent complete: 61.3%; Average loss: 3.0747
Iteration: 2454; Percent complete: 61.4%; Average loss: 2.9876
Iteration: 2455; Percent complete: 61.4%; Average loss: 2.9782
Iteration: 2456; Percent complete: 61.4%; Average loss: 3.2561
Iteration: 2457; Percent complete: 61.4%; Average loss: 3.2520
Iteration: 2458; Percent complete: 61.5%; Average loss: 2.7989
Iteration: 2459; Percent complete: 61.5%; Average loss: 3.0533
Iteration: 2460; Percent complete: 61.5%; Average loss: 3.1067
Iteration: 2461; Percent complete: 61.5%; Average loss: 2.9370
Iteration: 2462; Percent complete: 61.6%; Average loss: 3.1969
Iteration: 2463; Percent complete: 61.6%; Average loss: 3.0343
Iteration: 2464; Percent complete: 61.6%; Average loss: 3.1550
Iteration: 2465; Percent complete: 61.6%; Average loss: 3.0142
Iteration: 2466; Percent complete: 61.7%; Average loss: 3.2010
Iteration: 2467; Percent complete: 61.7%; Average loss: 3.1643
Iteration: 2468; Percent complete: 61.7%; Average loss: 3.0241
Iteration: 2469; Percent complete: 61.7%; Average loss: 3.0242
Iteration: 2470; Percent complete: 61.8%; Average loss: 3.1790
Iteration: 2471; Percent complete: 61.8%; Average loss: 3.1836
Iteration: 2472; Percent complete: 61.8%; Average loss: 2.8416
Iteration: 2473; Percent complete: 61.8%; Average loss: 2.8700
Iteration: 2474; Percent complete: 61.9%; Average loss: 3.0056
Iteration: 2475; Percent complete: 61.9%; Average loss: 3.1031
Iteration: 2476; Percent complete: 61.9%; Average loss: 3.2868
Iteration: 2477; Percent complete: 61.9%; Average loss: 3.0362
Iteration: 2478; Percent complete: 62.0%; Average loss: 3.1362
Iteration: 2479; Percent complete: 62.0%; Average loss: 2.9710
Iteration: 2480; Percent complete: 62.0%; Average loss: 2.9192
Iteration: 2481; Percent complete: 62.0%; Average loss: 3.0668
Iteration: 2482; Percent complete: 62.1%; Average loss: 2.9141
Iteration: 2483; Percent complete: 62.1%; Average loss: 2.9031
Iteration: 2484; Percent complete: 62.1%; Average loss: 3.1719
Iteration: 2485; Percent complete: 62.1%; Average loss: 2.8479
Iteration: 2486; Percent complete: 62.2%; Average loss: 2.9118
Iteration: 2487; Percent complete: 62.2%; Average loss: 3.1163
Iteration: 2488; Percent complete: 62.2%; Average loss: 3.0445
Iteration: 2489; Percent complete: 62.2%; Average loss: 2.9855
Iteration: 2490; Percent complete: 62.3%; Average loss: 3.0857
Iteration: 2491; Percent complete: 62.3%; Average loss: 3.1210
Iteration: 2492; Percent complete: 62.3%; Average loss: 2.8902
Iteration: 2493; Percent complete: 62.3%; Average loss: 3.0154
Iteration: 2494; Percent complete: 62.4%; Average loss: 3.1300
Iteration: 2495; Percent complete: 62.4%; Average loss: 3.0337
Iteration: 2496; Percent complete: 62.4%; Average loss: 3.0138
Iteration: 2497; Percent complete: 62.4%; Average loss: 3.2464
Iteration: 2498; Percent complete: 62.5%; Average loss: 3.2269
Iteration: 2499; Percent complete: 62.5%; Average loss: 3.1822
Iteration: 2500; Percent complete: 62.5%; Average loss: 3.2100
Iteration: 2501; Percent complete: 62.5%; Average loss: 2.9324
Iteration: 2502; Percent complete: 62.5%; Average loss: 3.2712
Iteration: 2503; Percent complete: 62.6%; Average loss: 2.8370
Iteration: 2504; Percent complete: 62.6%; Average loss: 3.1025
Iteration: 2505; Percent complete: 62.6%; Average loss: 2.9576
Iteration: 2506; Percent complete: 62.6%; Average loss: 3.1875
Iteration: 2507; Percent complete: 62.7%; Average loss: 2.8025
Iteration: 2508; Percent complete: 62.7%; Average loss: 3.0217
Iteration: 2509; Percent complete: 62.7%; Average loss: 3.1866
Iteration: 2510; Percent complete: 62.7%; Average loss: 2.7893
Iteration: 2511; Percent complete: 62.8%; Average loss: 2.9284
Iteration: 2512; Percent complete: 62.8%; Average loss: 3.1236
Iteration: 2513; Percent complete: 62.8%; Average loss: 2.8251
Iteration: 2514; Percent complete: 62.8%; Average loss: 3.1499
Iteration: 2515; Percent complete: 62.9%; Average loss: 3.2632
Iteration: 2516; Percent complete: 62.9%; Average loss: 3.1002
Iteration: 2517; Percent complete: 62.9%; Average loss: 3.0862
Iteration: 2518; Percent complete: 62.9%; Average loss: 2.8229
Iteration: 2519; Percent complete: 63.0%; Average loss: 3.0040
Iteration: 2520; Percent complete: 63.0%; Average loss: 3.0220
Iteration: 2521; Percent complete: 63.0%; Average loss: 2.8148
Iteration: 2522; Percent complete: 63.0%; Average loss: 3.1725
Iteration: 2523; Percent complete: 63.1%; Average loss: 2.9261
Iteration: 2524; Percent complete: 63.1%; Average loss: 2.8105
Iteration: 2525; Percent complete: 63.1%; Average loss: 2.9133
Iteration: 2526; Percent complete: 63.1%; Average loss: 3.4174
Iteration: 2527; Percent complete: 63.2%; Average loss: 3.0547
Iteration: 2528; Percent complete: 63.2%; Average loss: 2.8800
Iteration: 2529; Percent complete: 63.2%; Average loss: 2.8319
Iteration: 2530; Percent complete: 63.2%; Average loss: 2.8465
Iteration: 2531; Percent complete: 63.3%; Average loss: 3.0529
Iteration: 2532; Percent complete: 63.3%; Average loss: 2.9224
Iteration: 2533; Percent complete: 63.3%; Average loss: 3.0398
Iteration: 2534; Percent complete: 63.3%; Average loss: 3.0455
Iteration: 2535; Percent complete: 63.4%; Average loss: 3.0407
Iteration: 2536; Percent complete: 63.4%; Average loss: 3.0518
Iteration: 2537; Percent complete: 63.4%; Average loss: 2.9905
Iteration: 2538; Percent complete: 63.4%; Average loss: 3.0385
Iteration: 2539; Percent complete: 63.5%; Average loss: 2.8945
Iteration: 2540; Percent complete: 63.5%; Average loss: 3.1595
Iteration: 2541; Percent complete: 63.5%; Average loss: 3.3332
Iteration: 2542; Percent complete: 63.5%; Average loss: 3.0684
Iteration: 2543; Percent complete: 63.6%; Average loss: 3.0933
Iteration: 2544; Percent complete: 63.6%; Average loss: 3.1239
Iteration: 2545; Percent complete: 63.6%; Average loss: 2.9889
Iteration: 2546; Percent complete: 63.6%; Average loss: 2.6837
Iteration: 2547; Percent complete: 63.7%; Average loss: 2.9337
Iteration: 2548; Percent complete: 63.7%; Average loss: 3.1144
Iteration: 2549; Percent complete: 63.7%; Average loss: 3.2388
Iteration: 2550; Percent complete: 63.7%; Average loss: 2.6919
Iteration: 2551; Percent complete: 63.8%; Average loss: 3.1838
Iteration: 2552; Percent complete: 63.8%; Average loss: 3.1572
Iteration: 2553; Percent complete: 63.8%; Average loss: 2.9980
Iteration: 2554; Percent complete: 63.8%; Average loss: 2.9718
Iteration: 2555; Percent complete: 63.9%; Average loss: 3.0331
Iteration: 2556; Percent complete: 63.9%; Average loss: 3.0437
Iteration: 2557; Percent complete: 63.9%; Average loss: 3.0268
Iteration: 2558; Percent complete: 63.9%; Average loss: 2.7652
Iteration: 2559; Percent complete: 64.0%; Average loss: 3.2029
Iteration: 2560; Percent complete: 64.0%; Average loss: 2.9815
Iteration: 2561; Percent complete: 64.0%; Average loss: 3.1341
Iteration: 2562; Percent complete: 64.0%; Average loss: 2.9616
Iteration: 2563; Percent complete: 64.1%; Average loss: 3.0121
Iteration: 2564; Percent complete: 64.1%; Average loss: 3.0228
Iteration: 2565; Percent complete: 64.1%; Average loss: 3.0641
Iteration: 2566; Percent complete: 64.1%; Average loss: 3.0275
Iteration: 2567; Percent complete: 64.2%; Average loss: 3.0402
Iteration: 2568; Percent complete: 64.2%; Average loss: 3.0064
Iteration: 2569; Percent complete: 64.2%; Average loss: 2.9209
Iteration: 2570; Percent complete: 64.2%; Average loss: 2.8225
Iteration: 2571; Percent complete: 64.3%; Average loss: 3.0808
Iteration: 2572; Percent complete: 64.3%; Average loss: 2.9236
Iteration: 2573; Percent complete: 64.3%; Average loss: 2.8906
Iteration: 2574; Percent complete: 64.3%; Average loss: 3.1595
Iteration: 2575; Percent complete: 64.4%; Average loss: 3.1819
Iteration: 2576; Percent complete: 64.4%; Average loss: 2.9835
Iteration: 2577; Percent complete: 64.4%; Average loss: 3.0691
Iteration: 2578; Percent complete: 64.5%; Average loss: 2.9624
Iteration: 2579; Percent complete: 64.5%; Average loss: 2.9229
Iteration: 2580; Percent complete: 64.5%; Average loss: 3.0238
Iteration: 2581; Percent complete: 64.5%; Average loss: 3.1612
Iteration: 2582; Percent complete: 64.5%; Average loss: 3.2157
Iteration: 2583; Percent complete: 64.6%; Average loss: 3.1238
Iteration: 2584; Percent complete: 64.6%; Average loss: 3.2932
Iteration: 2585; Percent complete: 64.6%; Average loss: 2.8187
Iteration: 2586; Percent complete: 64.6%; Average loss: 2.7145
Iteration: 2587; Percent complete: 64.7%; Average loss: 3.0567
Iteration: 2588; Percent complete: 64.7%; Average loss: 2.7811
Iteration: 2589; Percent complete: 64.7%; Average loss: 2.9424
Iteration: 2590; Percent complete: 64.8%; Average loss: 3.1667
Iteration: 2591; Percent complete: 64.8%; Average loss: 3.1497
Iteration: 2592; Percent complete: 64.8%; Average loss: 2.7658
Iteration: 2593; Percent complete: 64.8%; Average loss: 3.1535
Iteration: 2594; Percent complete: 64.8%; Average loss: 2.9701
Iteration: 2595; Percent complete: 64.9%; Average loss: 3.0175
Iteration: 2596; Percent complete: 64.9%; Average loss: 3.0090
Iteration: 2597; Percent complete: 64.9%; Average loss: 3.1743
Iteration: 2598; Percent complete: 65.0%; Average loss: 3.0350
Iteration: 2599; Percent complete: 65.0%; Average loss: 3.1708
Iteration: 2600; Percent complete: 65.0%; Average loss: 2.9021
Iteration: 2601; Percent complete: 65.0%; Average loss: 3.1532
Iteration: 2602; Percent complete: 65.0%; Average loss: 2.9231
Iteration: 2603; Percent complete: 65.1%; Average loss: 2.7924
Iteration: 2604; Percent complete: 65.1%; Average loss: 3.1738
Iteration: 2605; Percent complete: 65.1%; Average loss: 3.1626
Iteration: 2606; Percent complete: 65.1%; Average loss: 2.8938
Iteration: 2607; Percent complete: 65.2%; Average loss: 2.8557
Iteration: 2608; Percent complete: 65.2%; Average loss: 3.0216
Iteration: 2609; Percent complete: 65.2%; Average loss: 3.1201
Iteration: 2610; Percent complete: 65.2%; Average loss: 3.0082
Iteration: 2611; Percent complete: 65.3%; Average loss: 3.1314
Iteration: 2612; Percent complete: 65.3%; Average loss: 3.2283
Iteration: 2613; Percent complete: 65.3%; Average loss: 2.6654
Iteration: 2614; Percent complete: 65.3%; Average loss: 3.0922
Iteration: 2615; Percent complete: 65.4%; Average loss: 2.8059
Iteration: 2616; Percent complete: 65.4%; Average loss: 3.1203
Iteration: 2617; Percent complete: 65.4%; Average loss: 2.8214
Iteration: 2618; Percent complete: 65.5%; Average loss: 2.9187
Iteration: 2619; Percent complete: 65.5%; Average loss: 2.8709
Iteration: 2620; Percent complete: 65.5%; Average loss: 2.8955
Iteration: 2621; Percent complete: 65.5%; Average loss: 3.1146
Iteration: 2622; Percent complete: 65.5%; Average loss: 3.2371
Iteration: 2623; Percent complete: 65.6%; Average loss: 2.8419
Iteration: 2624; Percent complete: 65.6%; Average loss: 3.0710
Iteration: 2625; Percent complete: 65.6%; Average loss: 3.2227
Iteration: 2626; Percent complete: 65.6%; Average loss: 2.9786
Iteration: 2627; Percent complete: 65.7%; Average loss: 2.9708
Iteration: 2628; Percent complete: 65.7%; Average loss: 3.0344
Iteration: 2629; Percent complete: 65.7%; Average loss: 2.9495
Iteration: 2630; Percent complete: 65.8%; Average loss: 2.9252
Iteration: 2631; Percent complete: 65.8%; Average loss: 2.8994
Iteration: 2632; Percent complete: 65.8%; Average loss: 2.7922
Iteration: 2633; Percent complete: 65.8%; Average loss: 2.8670
Iteration: 2634; Percent complete: 65.8%; Average loss: 3.0887
Iteration: 2635; Percent complete: 65.9%; Average loss: 2.8679
Iteration: 2636; Percent complete: 65.9%; Average loss: 2.9663
Iteration: 2637; Percent complete: 65.9%; Average loss: 3.1297
Iteration: 2638; Percent complete: 66.0%; Average loss: 3.0066
Iteration: 2639; Percent complete: 66.0%; Average loss: 3.1029
Iteration: 2640; Percent complete: 66.0%; Average loss: 3.1532
Iteration: 2641; Percent complete: 66.0%; Average loss: 3.0509
Iteration: 2642; Percent complete: 66.0%; Average loss: 3.0144
Iteration: 2643; Percent complete: 66.1%; Average loss: 3.0103
Iteration: 2644; Percent complete: 66.1%; Average loss: 2.8732
Iteration: 2645; Percent complete: 66.1%; Average loss: 2.8679
Iteration: 2646; Percent complete: 66.1%; Average loss: 2.9970
Iteration: 2647; Percent complete: 66.2%; Average loss: 3.0526
Iteration: 2648; Percent complete: 66.2%; Average loss: 2.9583
Iteration: 2649; Percent complete: 66.2%; Average loss: 2.8685
Iteration: 2650; Percent complete: 66.2%; Average loss: 3.0783
Iteration: 2651; Percent complete: 66.3%; Average loss: 3.0234
Iteration: 2652; Percent complete: 66.3%; Average loss: 3.0756
Iteration: 2653; Percent complete: 66.3%; Average loss: 3.1948
Iteration: 2654; Percent complete: 66.3%; Average loss: 2.7696
Iteration: 2655; Percent complete: 66.4%; Average loss: 2.7780
Iteration: 2656; Percent complete: 66.4%; Average loss: 3.1311
Iteration: 2657; Percent complete: 66.4%; Average loss: 2.9194
Iteration: 2658; Percent complete: 66.5%; Average loss: 3.0701
Iteration: 2659; Percent complete: 66.5%; Average loss: 3.0858
Iteration: 2660; Percent complete: 66.5%; Average loss: 3.0269
Iteration: 2661; Percent complete: 66.5%; Average loss: 2.7374
Iteration: 2662; Percent complete: 66.5%; Average loss: 3.0287
Iteration: 2663; Percent complete: 66.6%; Average loss: 3.0670
Iteration: 2664; Percent complete: 66.6%; Average loss: 3.1945
Iteration: 2665; Percent complete: 66.6%; Average loss: 3.0724
Iteration: 2666; Percent complete: 66.6%; Average loss: 3.0150
Iteration: 2667; Percent complete: 66.7%; Average loss: 3.1490
Iteration: 2668; Percent complete: 66.7%; Average loss: 2.9393
Iteration: 2669; Percent complete: 66.7%; Average loss: 3.1164
Iteration: 2670; Percent complete: 66.8%; Average loss: 3.1400
Iteration: 2671; Percent complete: 66.8%; Average loss: 2.9216
Iteration: 2672; Percent complete: 66.8%; Average loss: 3.4390
Iteration: 2673; Percent complete: 66.8%; Average loss: 2.9634
Iteration: 2674; Percent complete: 66.8%; Average loss: 3.0794
Iteration: 2675; Percent complete: 66.9%; Average loss: 2.9836
Iteration: 2676; Percent complete: 66.9%; Average loss: 2.8406
Iteration: 2677; Percent complete: 66.9%; Average loss: 2.9556
Iteration: 2678; Percent complete: 67.0%; Average loss: 3.1445
Iteration: 2679; Percent complete: 67.0%; Average loss: 3.1498
Iteration: 2680; Percent complete: 67.0%; Average loss: 2.8832
Iteration: 2681; Percent complete: 67.0%; Average loss: 3.0672
Iteration: 2682; Percent complete: 67.0%; Average loss: 3.1084
Iteration: 2683; Percent complete: 67.1%; Average loss: 3.0767
Iteration: 2684; Percent complete: 67.1%; Average loss: 2.8326
Iteration: 2685; Percent complete: 67.1%; Average loss: 3.2101
Iteration: 2686; Percent complete: 67.2%; Average loss: 2.6947
Iteration: 2687; Percent complete: 67.2%; Average loss: 3.0089
Iteration: 2688; Percent complete: 67.2%; Average loss: 2.9966
Iteration: 2689; Percent complete: 67.2%; Average loss: 2.9962
Iteration: 2690; Percent complete: 67.2%; Average loss: 2.9890
Iteration: 2691; Percent complete: 67.3%; Average loss: 3.1410
Iteration: 2692; Percent complete: 67.3%; Average loss: 2.9299
Iteration: 2693; Percent complete: 67.3%; Average loss: 3.1230
Iteration: 2694; Percent complete: 67.3%; Average loss: 3.1804
Iteration: 2695; Percent complete: 67.4%; Average loss: 2.8958
Iteration: 2696; Percent complete: 67.4%; Average loss: 3.1137
Iteration: 2697; Percent complete: 67.4%; Average loss: 3.0278
Iteration: 2698; Percent complete: 67.5%; Average loss: 2.9315
Iteration: 2699; Percent complete: 67.5%; Average loss: 2.9027
Iteration: 2700; Percent complete: 67.5%; Average loss: 3.0760
Iteration: 2701; Percent complete: 67.5%; Average loss: 2.5890
Iteration: 2702; Percent complete: 67.5%; Average loss: 2.9425
Iteration: 2703; Percent complete: 67.6%; Average loss: 3.0717
Iteration: 2704; Percent complete: 67.6%; Average loss: 3.2065
Iteration: 2705; Percent complete: 67.6%; Average loss: 2.7994
Iteration: 2706; Percent complete: 67.7%; Average loss: 2.8568
Iteration: 2707; Percent complete: 67.7%; Average loss: 3.1500
Iteration: 2708; Percent complete: 67.7%; Average loss: 2.8883
Iteration: 2709; Percent complete: 67.7%; Average loss: 2.7739
Iteration: 2710; Percent complete: 67.8%; Average loss: 3.1593
Iteration: 2711; Percent complete: 67.8%; Average loss: 3.0445
Iteration: 2712; Percent complete: 67.8%; Average loss: 2.9508
Iteration: 2713; Percent complete: 67.8%; Average loss: 3.1492
Iteration: 2714; Percent complete: 67.8%; Average loss: 3.1726
Iteration: 2715; Percent complete: 67.9%; Average loss: 2.9007
Iteration: 2716; Percent complete: 67.9%; Average loss: 3.1141
Iteration: 2717; Percent complete: 67.9%; Average loss: 3.0447
Iteration: 2718; Percent complete: 68.0%; Average loss: 2.8740
Iteration: 2719; Percent complete: 68.0%; Average loss: 3.3276
Iteration: 2720; Percent complete: 68.0%; Average loss: 2.9711
Iteration: 2721; Percent complete: 68.0%; Average loss: 2.9838
Iteration: 2722; Percent complete: 68.0%; Average loss: 2.8641
Iteration: 2723; Percent complete: 68.1%; Average loss: 2.7650
Iteration: 2724; Percent complete: 68.1%; Average loss: 2.6429
Iteration: 2725; Percent complete: 68.1%; Average loss: 2.8283
Iteration: 2726; Percent complete: 68.2%; Average loss: 3.1198
Iteration: 2727; Percent complete: 68.2%; Average loss: 3.1374
Iteration: 2728; Percent complete: 68.2%; Average loss: 2.8075
Iteration: 2729; Percent complete: 68.2%; Average loss: 2.6898
Iteration: 2730; Percent complete: 68.2%; Average loss: 2.9103
Iteration: 2731; Percent complete: 68.3%; Average loss: 2.9740
Iteration: 2732; Percent complete: 68.3%; Average loss: 3.1113
Iteration: 2733; Percent complete: 68.3%; Average loss: 2.9363
Iteration: 2734; Percent complete: 68.3%; Average loss: 2.8113
Iteration: 2735; Percent complete: 68.4%; Average loss: 3.0221
Iteration: 2736; Percent complete: 68.4%; Average loss: 2.9865
Iteration: 2737; Percent complete: 68.4%; Average loss: 3.0812
Iteration: 2738; Percent complete: 68.5%; Average loss: 3.2028
Iteration: 2739; Percent complete: 68.5%; Average loss: 2.9234
Iteration: 2740; Percent complete: 68.5%; Average loss: 2.9124
Iteration: 2741; Percent complete: 68.5%; Average loss: 2.9846
Iteration: 2742; Percent complete: 68.5%; Average loss: 3.0971
Iteration: 2743; Percent complete: 68.6%; Average loss: 2.9458
Iteration: 2744; Percent complete: 68.6%; Average loss: 2.8311
Iteration: 2745; Percent complete: 68.6%; Average loss: 3.1712
Iteration: 2746; Percent complete: 68.7%; Average loss: 2.8821
Iteration: 2747; Percent complete: 68.7%; Average loss: 3.0813
Iteration: 2748; Percent complete: 68.7%; Average loss: 2.9616
Iteration: 2749; Percent complete: 68.7%; Average loss: 3.0126
Iteration: 2750; Percent complete: 68.8%; Average loss: 2.8988
Iteration: 2751; Percent complete: 68.8%; Average loss: 3.0556
Iteration: 2752; Percent complete: 68.8%; Average loss: 3.0345
Iteration: 2753; Percent complete: 68.8%; Average loss: 2.8501
Iteration: 2754; Percent complete: 68.8%; Average loss: 2.8105
Iteration: 2755; Percent complete: 68.9%; Average loss: 2.9529
Iteration: 2756; Percent complete: 68.9%; Average loss: 2.8756
Iteration: 2757; Percent complete: 68.9%; Average loss: 2.6266
Iteration: 2758; Percent complete: 69.0%; Average loss: 2.9821
Iteration: 2759; Percent complete: 69.0%; Average loss: 2.9291
Iteration: 2760; Percent complete: 69.0%; Average loss: 3.0385
Iteration: 2761; Percent complete: 69.0%; Average loss: 3.0999
Iteration: 2762; Percent complete: 69.0%; Average loss: 3.3594
Iteration: 2763; Percent complete: 69.1%; Average loss: 3.3400
Iteration: 2764; Percent complete: 69.1%; Average loss: 2.9966
Iteration: 2765; Percent complete: 69.1%; Average loss: 2.8178
Iteration: 2766; Percent complete: 69.2%; Average loss: 3.2009
Iteration: 2767; Percent complete: 69.2%; Average loss: 2.8437
Iteration: 2768; Percent complete: 69.2%; Average loss: 2.7050
Iteration: 2769; Percent complete: 69.2%; Average loss: 2.9662
Iteration: 2770; Percent complete: 69.2%; Average loss: 3.1342
Iteration: 2771; Percent complete: 69.3%; Average loss: 2.8914
Iteration: 2772; Percent complete: 69.3%; Average loss: 2.6822
Iteration: 2773; Percent complete: 69.3%; Average loss: 2.8072
Iteration: 2774; Percent complete: 69.3%; Average loss: 3.0835
Iteration: 2775; Percent complete: 69.4%; Average loss: 2.9549
Iteration: 2776; Percent complete: 69.4%; Average loss: 2.9277
Iteration: 2777; Percent complete: 69.4%; Average loss: 3.0962
Iteration: 2778; Percent complete: 69.5%; Average loss: 3.1521
Iteration: 2779; Percent complete: 69.5%; Average loss: 2.9967
Iteration: 2780; Percent complete: 69.5%; Average loss: 2.9311
Iteration: 2781; Percent complete: 69.5%; Average loss: 3.0223
Iteration: 2782; Percent complete: 69.5%; Average loss: 2.8547
Iteration: 2783; Percent complete: 69.6%; Average loss: 2.9672
Iteration: 2784; Percent complete: 69.6%; Average loss: 3.0039
Iteration: 2785; Percent complete: 69.6%; Average loss: 3.1854
Iteration: 2786; Percent complete: 69.7%; Average loss: 2.8871
Iteration: 2787; Percent complete: 69.7%; Average loss: 2.8525
Iteration: 2788; Percent complete: 69.7%; Average loss: 3.0408
Iteration: 2789; Percent complete: 69.7%; Average loss: 3.2175
Iteration: 2790; Percent complete: 69.8%; Average loss: 2.7509
Iteration: 2791; Percent complete: 69.8%; Average loss: 2.8191
Iteration: 2792; Percent complete: 69.8%; Average loss: 3.1538
Iteration: 2793; Percent complete: 69.8%; Average loss: 3.2488
Iteration: 2794; Percent complete: 69.8%; Average loss: 2.9978
Iteration: 2795; Percent complete: 69.9%; Average loss: 2.9149
Iteration: 2796; Percent complete: 69.9%; Average loss: 2.8083
Iteration: 2797; Percent complete: 69.9%; Average loss: 2.9697
Iteration: 2798; Percent complete: 70.0%; Average loss: 3.1097
Iteration: 2799; Percent complete: 70.0%; Average loss: 2.9080
Iteration: 2800; Percent complete: 70.0%; Average loss: 2.7059
Iteration: 2801; Percent complete: 70.0%; Average loss: 2.8575
Iteration: 2802; Percent complete: 70.0%; Average loss: 3.0483
Iteration: 2803; Percent complete: 70.1%; Average loss: 3.0429
Iteration: 2804; Percent complete: 70.1%; Average loss: 3.0341
Iteration: 2805; Percent complete: 70.1%; Average loss: 2.8840
Iteration: 2806; Percent complete: 70.2%; Average loss: 2.7578
Iteration: 2807; Percent complete: 70.2%; Average loss: 3.1248
Iteration: 2808; Percent complete: 70.2%; Average loss: 2.5380
Iteration: 2809; Percent complete: 70.2%; Average loss: 3.0019
Iteration: 2810; Percent complete: 70.2%; Average loss: 2.9326
Iteration: 2811; Percent complete: 70.3%; Average loss: 2.6999
Iteration: 2812; Percent complete: 70.3%; Average loss: 2.8701
Iteration: 2813; Percent complete: 70.3%; Average loss: 2.9733
Iteration: 2814; Percent complete: 70.3%; Average loss: 2.8976
Iteration: 2815; Percent complete: 70.4%; Average loss: 3.0343
Iteration: 2816; Percent complete: 70.4%; Average loss: 2.9861
Iteration: 2817; Percent complete: 70.4%; Average loss: 2.9023
Iteration: 2818; Percent complete: 70.5%; Average loss: 2.9032
Iteration: 2819; Percent complete: 70.5%; Average loss: 2.7280
Iteration: 2820; Percent complete: 70.5%; Average loss: 3.0148
Iteration: 2821; Percent complete: 70.5%; Average loss: 2.8975
Iteration: 2822; Percent complete: 70.5%; Average loss: 2.8715
Iteration: 2823; Percent complete: 70.6%; Average loss: 2.9360
Iteration: 2824; Percent complete: 70.6%; Average loss: 2.8790
Iteration: 2825; Percent complete: 70.6%; Average loss: 3.0842
Iteration: 2826; Percent complete: 70.7%; Average loss: 2.9820
Iteration: 2827; Percent complete: 70.7%; Average loss: 2.9568
Iteration: 2828; Percent complete: 70.7%; Average loss: 3.0006
Iteration: 2829; Percent complete: 70.7%; Average loss: 2.8414
Iteration: 2830; Percent complete: 70.8%; Average loss: 2.9875
Iteration: 2831; Percent complete: 70.8%; Average loss: 2.8989
Iteration: 2832; Percent complete: 70.8%; Average loss: 2.9904
Iteration: 2833; Percent complete: 70.8%; Average loss: 2.8340
Iteration: 2834; Percent complete: 70.9%; Average loss: 3.1798
Iteration: 2835; Percent complete: 70.9%; Average loss: 2.9441
Iteration: 2836; Percent complete: 70.9%; Average loss: 3.1348
Iteration: 2837; Percent complete: 70.9%; Average loss: 2.7782
Iteration: 2838; Percent complete: 71.0%; Average loss: 2.8771
Iteration: 2839; Percent complete: 71.0%; Average loss: 3.1113
Iteration: 2840; Percent complete: 71.0%; Average loss: 2.9551
Iteration: 2841; Percent complete: 71.0%; Average loss: 2.7399
Iteration: 2842; Percent complete: 71.0%; Average loss: 3.0334
Iteration: 2843; Percent complete: 71.1%; Average loss: 2.8925
Iteration: 2844; Percent complete: 71.1%; Average loss: 2.8379
Iteration: 2845; Percent complete: 71.1%; Average loss: 2.9134
Iteration: 2846; Percent complete: 71.2%; Average loss: 2.7478
Iteration: 2847; Percent complete: 71.2%; Average loss: 2.9658
Iteration: 2848; Percent complete: 71.2%; Average loss: 2.8329
Iteration: 2849; Percent complete: 71.2%; Average loss: 3.0259
Iteration: 2850; Percent complete: 71.2%; Average loss: 3.2500
Iteration: 2851; Percent complete: 71.3%; Average loss: 3.0410
Iteration: 2852; Percent complete: 71.3%; Average loss: 3.1300
Iteration: 2853; Percent complete: 71.3%; Average loss: 3.1575
Iteration: 2854; Percent complete: 71.4%; Average loss: 3.0614
Iteration: 2855; Percent complete: 71.4%; Average loss: 2.8326
Iteration: 2856; Percent complete: 71.4%; Average loss: 2.8612
Iteration: 2857; Percent complete: 71.4%; Average loss: 3.1167
Iteration: 2858; Percent complete: 71.5%; Average loss: 2.8868
Iteration: 2859; Percent complete: 71.5%; Average loss: 2.9473
Iteration: 2860; Percent complete: 71.5%; Average loss: 2.8077
Iteration: 2861; Percent complete: 71.5%; Average loss: 2.9900
Iteration: 2862; Percent complete: 71.5%; Average loss: 2.9715
Iteration: 2863; Percent complete: 71.6%; Average loss: 3.0736
Iteration: 2864; Percent complete: 71.6%; Average loss: 2.6170
Iteration: 2865; Percent complete: 71.6%; Average loss: 2.8926
Iteration: 2866; Percent complete: 71.7%; Average loss: 3.0310
Iteration: 2867; Percent complete: 71.7%; Average loss: 2.8701
Iteration: 2868; Percent complete: 71.7%; Average loss: 2.8419
Iteration: 2869; Percent complete: 71.7%; Average loss: 2.6824
Iteration: 2870; Percent complete: 71.8%; Average loss: 3.1548
Iteration: 2871; Percent complete: 71.8%; Average loss: 3.0179
Iteration: 2872; Percent complete: 71.8%; Average loss: 3.0167
Iteration: 2873; Percent complete: 71.8%; Average loss: 3.0017
Iteration: 2874; Percent complete: 71.9%; Average loss: 3.1087
Iteration: 2875; Percent complete: 71.9%; Average loss: 2.9759
Iteration: 2876; Percent complete: 71.9%; Average loss: 2.7766
Iteration: 2877; Percent complete: 71.9%; Average loss: 2.8426
Iteration: 2878; Percent complete: 72.0%; Average loss: 2.7599
Iteration: 2879; Percent complete: 72.0%; Average loss: 2.6098
Iteration: 2880; Percent complete: 72.0%; Average loss: 2.9319
Iteration: 2881; Percent complete: 72.0%; Average loss: 3.0317
Iteration: 2882; Percent complete: 72.0%; Average loss: 2.8751
Iteration: 2883; Percent complete: 72.1%; Average loss: 3.0431
Iteration: 2884; Percent complete: 72.1%; Average loss: 3.2324
Iteration: 2885; Percent complete: 72.1%; Average loss: 3.1603
Iteration: 2886; Percent complete: 72.2%; Average loss: 2.9991
Iteration: 2887; Percent complete: 72.2%; Average loss: 2.9633
Iteration: 2888; Percent complete: 72.2%; Average loss: 2.8374
Iteration: 2889; Percent complete: 72.2%; Average loss: 2.8337
Iteration: 2890; Percent complete: 72.2%; Average loss: 3.0201
Iteration: 2891; Percent complete: 72.3%; Average loss: 2.9327
Iteration: 2892; Percent complete: 72.3%; Average loss: 2.7408
Iteration: 2893; Percent complete: 72.3%; Average loss: 2.7072
Iteration: 2894; Percent complete: 72.4%; Average loss: 2.9052
Iteration: 2895; Percent complete: 72.4%; Average loss: 2.8454
Iteration: 2896; Percent complete: 72.4%; Average loss: 2.8329
Iteration: 2897; Percent complete: 72.4%; Average loss: 2.9316
Iteration: 2898; Percent complete: 72.5%; Average loss: 3.0411
Iteration: 2899; Percent complete: 72.5%; Average loss: 2.8038
Iteration: 2900; Percent complete: 72.5%; Average loss: 2.6588
Iteration: 2901; Percent complete: 72.5%; Average loss: 2.8570
Iteration: 2902; Percent complete: 72.5%; Average loss: 2.8729
Iteration: 2903; Percent complete: 72.6%; Average loss: 2.7394
Iteration: 2904; Percent complete: 72.6%; Average loss: 2.8519
Iteration: 2905; Percent complete: 72.6%; Average loss: 2.9889
Iteration: 2906; Percent complete: 72.7%; Average loss: 2.8998
Iteration: 2907; Percent complete: 72.7%; Average loss: 3.0670
Iteration: 2908; Percent complete: 72.7%; Average loss: 2.9074
Iteration: 2909; Percent complete: 72.7%; Average loss: 3.0604
Iteration: 2910; Percent complete: 72.8%; Average loss: 2.8749
Iteration: 2911; Percent complete: 72.8%; Average loss: 2.8490
Iteration: 2912; Percent complete: 72.8%; Average loss: 2.9958
Iteration: 2913; Percent complete: 72.8%; Average loss: 2.8199
Iteration: 2914; Percent complete: 72.9%; Average loss: 2.7048
Iteration: 2915; Percent complete: 72.9%; Average loss: 3.0553
Iteration: 2916; Percent complete: 72.9%; Average loss: 2.9058
Iteration: 2917; Percent complete: 72.9%; Average loss: 2.9977
Iteration: 2918; Percent complete: 73.0%; Average loss: 2.8964
Iteration: 2919; Percent complete: 73.0%; Average loss: 3.0607
Iteration: 2920; Percent complete: 73.0%; Average loss: 2.8256
Iteration: 2921; Percent complete: 73.0%; Average loss: 2.8606
Iteration: 2922; Percent complete: 73.0%; Average loss: 2.9537
Iteration: 2923; Percent complete: 73.1%; Average loss: 2.9619
Iteration: 2924; Percent complete: 73.1%; Average loss: 2.5656
Iteration: 2925; Percent complete: 73.1%; Average loss: 2.8227
Iteration: 2926; Percent complete: 73.2%; Average loss: 2.9286
Iteration: 2927; Percent complete: 73.2%; Average loss: 2.9768
Iteration: 2928; Percent complete: 73.2%; Average loss: 2.7418
Iteration: 2929; Percent complete: 73.2%; Average loss: 2.8640
Iteration: 2930; Percent complete: 73.2%; Average loss: 2.7675
Iteration: 2931; Percent complete: 73.3%; Average loss: 2.8033
Iteration: 2932; Percent complete: 73.3%; Average loss: 3.1021
Iteration: 2933; Percent complete: 73.3%; Average loss: 2.9852
Iteration: 2934; Percent complete: 73.4%; Average loss: 3.0193
Iteration: 2935; Percent complete: 73.4%; Average loss: 3.1088
Iteration: 2936; Percent complete: 73.4%; Average loss: 2.7067
Iteration: 2937; Percent complete: 73.4%; Average loss: 3.0046
Iteration: 2938; Percent complete: 73.5%; Average loss: 2.8528
Iteration: 2939; Percent complete: 73.5%; Average loss: 3.1596
Iteration: 2940; Percent complete: 73.5%; Average loss: 2.8095
Iteration: 2941; Percent complete: 73.5%; Average loss: 2.9515
Iteration: 2942; Percent complete: 73.6%; Average loss: 2.9520
Iteration: 2943; Percent complete: 73.6%; Average loss: 2.7130
Iteration: 2944; Percent complete: 73.6%; Average loss: 2.6948
Iteration: 2945; Percent complete: 73.6%; Average loss: 3.0453
Iteration: 2946; Percent complete: 73.7%; Average loss: 3.0789
Iteration: 2947; Percent complete: 73.7%; Average loss: 2.9766
Iteration: 2948; Percent complete: 73.7%; Average loss: 3.1181
Iteration: 2949; Percent complete: 73.7%; Average loss: 2.9121
Iteration: 2950; Percent complete: 73.8%; Average loss: 2.8567
Iteration: 2951; Percent complete: 73.8%; Average loss: 2.9741
Iteration: 2952; Percent complete: 73.8%; Average loss: 3.0548
Iteration: 2953; Percent complete: 73.8%; Average loss: 2.9663
Iteration: 2954; Percent complete: 73.9%; Average loss: 2.8820
Iteration: 2955; Percent complete: 73.9%; Average loss: 2.9840
Iteration: 2956; Percent complete: 73.9%; Average loss: 2.9098
Iteration: 2957; Percent complete: 73.9%; Average loss: 2.9257
Iteration: 2958; Percent complete: 74.0%; Average loss: 2.8324
Iteration: 2959; Percent complete: 74.0%; Average loss: 2.8901
Iteration: 2960; Percent complete: 74.0%; Average loss: 2.8492
Iteration: 2961; Percent complete: 74.0%; Average loss: 2.8042
Iteration: 2962; Percent complete: 74.1%; Average loss: 2.9122
Iteration: 2963; Percent complete: 74.1%; Average loss: 2.6480
Iteration: 2964; Percent complete: 74.1%; Average loss: 3.0523
Iteration: 2965; Percent complete: 74.1%; Average loss: 3.0498
Iteration: 2966; Percent complete: 74.2%; Average loss: 2.8151
Iteration: 2967; Percent complete: 74.2%; Average loss: 3.0585
Iteration: 2968; Percent complete: 74.2%; Average loss: 2.6606
Iteration: 2969; Percent complete: 74.2%; Average loss: 2.7471
Iteration: 2970; Percent complete: 74.2%; Average loss: 2.8399
Iteration: 2971; Percent complete: 74.3%; Average loss: 2.9743
Iteration: 2972; Percent complete: 74.3%; Average loss: 3.2276
Iteration: 2973; Percent complete: 74.3%; Average loss: 3.0204
Iteration: 2974; Percent complete: 74.4%; Average loss: 3.0563
Iteration: 2975; Percent complete: 74.4%; Average loss: 2.9151
Iteration: 2976; Percent complete: 74.4%; Average loss: 2.8905
Iteration: 2977; Percent complete: 74.4%; Average loss: 2.9977
Iteration: 2978; Percent complete: 74.5%; Average loss: 2.8599
Iteration: 2979; Percent complete: 74.5%; Average loss: 2.9653
Iteration: 2980; Percent complete: 74.5%; Average loss: 2.7257
Iteration: 2981; Percent complete: 74.5%; Average loss: 2.9231
Iteration: 2982; Percent complete: 74.6%; Average loss: 2.7986
Iteration: 2983; Percent complete: 74.6%; Average loss: 3.0272
Iteration: 2984; Percent complete: 74.6%; Average loss: 2.6683
Iteration: 2985; Percent complete: 74.6%; Average loss: 2.9080
Iteration: 2986; Percent complete: 74.7%; Average loss: 2.8959
Iteration: 2987; Percent complete: 74.7%; Average loss: 3.1069
Iteration: 2988; Percent complete: 74.7%; Average loss: 2.8391
Iteration: 2989; Percent complete: 74.7%; Average loss: 2.8920
Iteration: 2990; Percent complete: 74.8%; Average loss: 2.9110
Iteration: 2991; Percent complete: 74.8%; Average loss: 2.7282
Iteration: 2992; Percent complete: 74.8%; Average loss: 2.7369
Iteration: 2993; Percent complete: 74.8%; Average loss: 2.8316
Iteration: 2994; Percent complete: 74.9%; Average loss: 2.8423
Iteration: 2995; Percent complete: 74.9%; Average loss: 2.9115
Iteration: 2996; Percent complete: 74.9%; Average loss: 2.8437
Iteration: 2997; Percent complete: 74.9%; Average loss: 2.9643
Iteration: 2998; Percent complete: 75.0%; Average loss: 2.8792
Iteration: 2999; Percent complete: 75.0%; Average loss: 2.7901
Iteration: 3000; Percent complete: 75.0%; Average loss: 2.9062
Iteration: 3001; Percent complete: 75.0%; Average loss: 2.7071
Iteration: 3002; Percent complete: 75.0%; Average loss: 3.1140
Iteration: 3003; Percent complete: 75.1%; Average loss: 2.9862
Iteration: 3004; Percent complete: 75.1%; Average loss: 3.0403
Iteration: 3005; Percent complete: 75.1%; Average loss: 2.9588
Iteration: 3006; Percent complete: 75.1%; Average loss: 3.1594
Iteration: 3007; Percent complete: 75.2%; Average loss: 2.8622
Iteration: 3008; Percent complete: 75.2%; Average loss: 2.8584
Iteration: 3009; Percent complete: 75.2%; Average loss: 2.6641
Iteration: 3010; Percent complete: 75.2%; Average loss: 3.0360
Iteration: 3011; Percent complete: 75.3%; Average loss: 2.8987
Iteration: 3012; Percent complete: 75.3%; Average loss: 3.0053
Iteration: 3013; Percent complete: 75.3%; Average loss: 2.8463
Iteration: 3014; Percent complete: 75.3%; Average loss: 2.7445
Iteration: 3015; Percent complete: 75.4%; Average loss: 2.7534
Iteration: 3016; Percent complete: 75.4%; Average loss: 2.8807
Iteration: 3017; Percent complete: 75.4%; Average loss: 2.7821
Iteration: 3018; Percent complete: 75.4%; Average loss: 2.6975
Iteration: 3019; Percent complete: 75.5%; Average loss: 2.9571
Iteration: 3020; Percent complete: 75.5%; Average loss: 2.8694
Iteration: 3021; Percent complete: 75.5%; Average loss: 3.2194
Iteration: 3022; Percent complete: 75.5%; Average loss: 2.7821
Iteration: 3023; Percent complete: 75.6%; Average loss: 2.8196
Iteration: 3024; Percent complete: 75.6%; Average loss: 2.9252
Iteration: 3025; Percent complete: 75.6%; Average loss: 2.8747
Iteration: 3026; Percent complete: 75.6%; Average loss: 2.8296
Iteration: 3027; Percent complete: 75.7%; Average loss: 3.0680
Iteration: 3028; Percent complete: 75.7%; Average loss: 2.8530
Iteration: 3029; Percent complete: 75.7%; Average loss: 2.9074
Iteration: 3030; Percent complete: 75.8%; Average loss: 2.5941
Iteration: 3031; Percent complete: 75.8%; Average loss: 2.9109
Iteration: 3032; Percent complete: 75.8%; Average loss: 2.9426
Iteration: 3033; Percent complete: 75.8%; Average loss: 2.9878
Iteration: 3034; Percent complete: 75.8%; Average loss: 2.8625
Iteration: 3035; Percent complete: 75.9%; Average loss: 3.0601
Iteration: 3036; Percent complete: 75.9%; Average loss: 2.9359
Iteration: 3037; Percent complete: 75.9%; Average loss: 2.9135
Iteration: 3038; Percent complete: 75.9%; Average loss: 2.9865
Iteration: 3039; Percent complete: 76.0%; Average loss: 2.8385
Iteration: 3040; Percent complete: 76.0%; Average loss: 2.8522
Iteration: 3041; Percent complete: 76.0%; Average loss: 2.8226
Iteration: 3042; Percent complete: 76.0%; Average loss: 3.0015
Iteration: 3043; Percent complete: 76.1%; Average loss: 2.7760
Iteration: 3044; Percent complete: 76.1%; Average loss: 2.8349
Iteration: 3045; Percent complete: 76.1%; Average loss: 2.9788
Iteration: 3046; Percent complete: 76.1%; Average loss: 2.8249
Iteration: 3047; Percent complete: 76.2%; Average loss: 2.9813
Iteration: 3048; Percent complete: 76.2%; Average loss: 3.1635
Iteration: 3049; Percent complete: 76.2%; Average loss: 2.7878
Iteration: 3050; Percent complete: 76.2%; Average loss: 2.9846
Iteration: 3051; Percent complete: 76.3%; Average loss: 2.8968
Iteration: 3052; Percent complete: 76.3%; Average loss: 2.9363
Iteration: 3053; Percent complete: 76.3%; Average loss: 2.9855
Iteration: 3054; Percent complete: 76.3%; Average loss: 2.6006
Iteration: 3055; Percent complete: 76.4%; Average loss: 3.1217
Iteration: 3056; Percent complete: 76.4%; Average loss: 2.9096
Iteration: 3057; Percent complete: 76.4%; Average loss: 2.7085
Iteration: 3058; Percent complete: 76.4%; Average loss: 2.9756
Iteration: 3059; Percent complete: 76.5%; Average loss: 3.0428
Iteration: 3060; Percent complete: 76.5%; Average loss: 2.7456
Iteration: 3061; Percent complete: 76.5%; Average loss: 2.8842
Iteration: 3062; Percent complete: 76.5%; Average loss: 2.9479
Iteration: 3063; Percent complete: 76.6%; Average loss: 2.5670
Iteration: 3064; Percent complete: 76.6%; Average loss: 2.7123
Iteration: 3065; Percent complete: 76.6%; Average loss: 2.7380
Iteration: 3066; Percent complete: 76.6%; Average loss: 2.6779
Iteration: 3067; Percent complete: 76.7%; Average loss: 2.8052
Iteration: 3068; Percent complete: 76.7%; Average loss: 2.9511
Iteration: 3069; Percent complete: 76.7%; Average loss: 2.7085
Iteration: 3070; Percent complete: 76.8%; Average loss: 2.8489
Iteration: 3071; Percent complete: 76.8%; Average loss: 2.8921
Iteration: 3072; Percent complete: 76.8%; Average loss: 3.0223
Iteration: 3073; Percent complete: 76.8%; Average loss: 2.8850
Iteration: 3074; Percent complete: 76.8%; Average loss: 3.0246
Iteration: 3075; Percent complete: 76.9%; Average loss: 2.5989
Iteration: 3076; Percent complete: 76.9%; Average loss: 2.5744
Iteration: 3077; Percent complete: 76.9%; Average loss: 2.7329
Iteration: 3078; Percent complete: 77.0%; Average loss: 2.7512
Iteration: 3079; Percent complete: 77.0%; Average loss: 2.8754
Iteration: 3080; Percent complete: 77.0%; Average loss: 2.7206
Iteration: 3081; Percent complete: 77.0%; Average loss: 2.9168
Iteration: 3082; Percent complete: 77.0%; Average loss: 3.0458
Iteration: 3083; Percent complete: 77.1%; Average loss: 2.9219
Iteration: 3084; Percent complete: 77.1%; Average loss: 2.7293
Iteration: 3085; Percent complete: 77.1%; Average loss: 3.1439
Iteration: 3086; Percent complete: 77.1%; Average loss: 2.7967
Iteration: 3087; Percent complete: 77.2%; Average loss: 2.8204
Iteration: 3088; Percent complete: 77.2%; Average loss: 3.2371
Iteration: 3089; Percent complete: 77.2%; Average loss: 3.0199
Iteration: 3090; Percent complete: 77.2%; Average loss: 2.6837
Iteration: 3091; Percent complete: 77.3%; Average loss: 3.0901
Iteration: 3092; Percent complete: 77.3%; Average loss: 2.9149
Iteration: 3093; Percent complete: 77.3%; Average loss: 2.8219
Iteration: 3094; Percent complete: 77.3%; Average loss: 2.8698
Iteration: 3095; Percent complete: 77.4%; Average loss: 2.7077
Iteration: 3096; Percent complete: 77.4%; Average loss: 2.9970
Iteration: 3097; Percent complete: 77.4%; Average loss: 2.9440
Iteration: 3098; Percent complete: 77.5%; Average loss: 2.8431
Iteration: 3099; Percent complete: 77.5%; Average loss: 2.6495
Iteration: 3100; Percent complete: 77.5%; Average loss: 2.8167
Iteration: 3101; Percent complete: 77.5%; Average loss: 3.0020
Iteration: 3102; Percent complete: 77.5%; Average loss: 2.9510
Iteration: 3103; Percent complete: 77.6%; Average loss: 2.8364
Iteration: 3104; Percent complete: 77.6%; Average loss: 3.0381
Iteration: 3105; Percent complete: 77.6%; Average loss: 2.9434
Iteration: 3106; Percent complete: 77.6%; Average loss: 2.7900
Iteration: 3107; Percent complete: 77.7%; Average loss: 2.9649
Iteration: 3108; Percent complete: 77.7%; Average loss: 3.1068
Iteration: 3109; Percent complete: 77.7%; Average loss: 3.1060
Iteration: 3110; Percent complete: 77.8%; Average loss: 2.7372
Iteration: 3111; Percent complete: 77.8%; Average loss: 2.9441
Iteration: 3112; Percent complete: 77.8%; Average loss: 2.5699
Iteration: 3113; Percent complete: 77.8%; Average loss: 2.6535
Iteration: 3114; Percent complete: 77.8%; Average loss: 2.9797
Iteration: 3115; Percent complete: 77.9%; Average loss: 2.8564
Iteration: 3116; Percent complete: 77.9%; Average loss: 2.5992
Iteration: 3117; Percent complete: 77.9%; Average loss: 2.7378
Iteration: 3118; Percent complete: 78.0%; Average loss: 2.9779
Iteration: 3119; Percent complete: 78.0%; Average loss: 2.9339
Iteration: 3120; Percent complete: 78.0%; Average loss: 2.8327
Iteration: 3121; Percent complete: 78.0%; Average loss: 3.0537
Iteration: 3122; Percent complete: 78.0%; Average loss: 3.0539
Iteration: 3123; Percent complete: 78.1%; Average loss: 2.8796
Iteration: 3124; Percent complete: 78.1%; Average loss: 2.7841
Iteration: 3125; Percent complete: 78.1%; Average loss: 3.0395
Iteration: 3126; Percent complete: 78.1%; Average loss: 2.8703
Iteration: 3127; Percent complete: 78.2%; Average loss: 3.0802
Iteration: 3128; Percent complete: 78.2%; Average loss: 3.0335
Iteration: 3129; Percent complete: 78.2%; Average loss: 2.9341
Iteration: 3130; Percent complete: 78.2%; Average loss: 2.6652
Iteration: 3131; Percent complete: 78.3%; Average loss: 3.0782
Iteration: 3132; Percent complete: 78.3%; Average loss: 2.8890
Iteration: 3133; Percent complete: 78.3%; Average loss: 2.7865
Iteration: 3134; Percent complete: 78.3%; Average loss: 3.0809
Iteration: 3135; Percent complete: 78.4%; Average loss: 3.1162
Iteration: 3136; Percent complete: 78.4%; Average loss: 2.7947
Iteration: 3137; Percent complete: 78.4%; Average loss: 2.7671
Iteration: 3138; Percent complete: 78.5%; Average loss: 2.5755
Iteration: 3139; Percent complete: 78.5%; Average loss: 3.1807
Iteration: 3140; Percent complete: 78.5%; Average loss: 2.6557
Iteration: 3141; Percent complete: 78.5%; Average loss: 2.9652
Iteration: 3142; Percent complete: 78.5%; Average loss: 2.9085
Iteration: 3143; Percent complete: 78.6%; Average loss: 2.8548
Iteration: 3144; Percent complete: 78.6%; Average loss: 2.6006
Iteration: 3145; Percent complete: 78.6%; Average loss: 2.8006
Iteration: 3146; Percent complete: 78.6%; Average loss: 2.6480
Iteration: 3147; Percent complete: 78.7%; Average loss: 2.8945
Iteration: 3148; Percent complete: 78.7%; Average loss: 2.5975
Iteration: 3149; Percent complete: 78.7%; Average loss: 2.9223
Iteration: 3150; Percent complete: 78.8%; Average loss: 2.7848
Iteration: 3151; Percent complete: 78.8%; Average loss: 2.6653
Iteration: 3152; Percent complete: 78.8%; Average loss: 2.7012
Iteration: 3153; Percent complete: 78.8%; Average loss: 2.9255
Iteration: 3154; Percent complete: 78.8%; Average loss: 3.0399
Iteration: 3155; Percent complete: 78.9%; Average loss: 2.8723
Iteration: 3156; Percent complete: 78.9%; Average loss: 2.8605
Iteration: 3157; Percent complete: 78.9%; Average loss: 2.7104
Iteration: 3158; Percent complete: 79.0%; Average loss: 2.8881
Iteration: 3159; Percent complete: 79.0%; Average loss: 2.8717
Iteration: 3160; Percent complete: 79.0%; Average loss: 2.8894
Iteration: 3161; Percent complete: 79.0%; Average loss: 2.8408
Iteration: 3162; Percent complete: 79.0%; Average loss: 2.7971
Iteration: 3163; Percent complete: 79.1%; Average loss: 2.9813
Iteration: 3164; Percent complete: 79.1%; Average loss: 2.8303
Iteration: 3165; Percent complete: 79.1%; Average loss: 2.8802
Iteration: 3166; Percent complete: 79.1%; Average loss: 2.9226
Iteration: 3167; Percent complete: 79.2%; Average loss: 2.8865
Iteration: 3168; Percent complete: 79.2%; Average loss: 2.9016
Iteration: 3169; Percent complete: 79.2%; Average loss: 2.8074
Iteration: 3170; Percent complete: 79.2%; Average loss: 2.7624
Iteration: 3171; Percent complete: 79.3%; Average loss: 3.0308
Iteration: 3172; Percent complete: 79.3%; Average loss: 2.7913
Iteration: 3173; Percent complete: 79.3%; Average loss: 2.8224
Iteration: 3174; Percent complete: 79.3%; Average loss: 2.6986
Iteration: 3175; Percent complete: 79.4%; Average loss: 2.9844
Iteration: 3176; Percent complete: 79.4%; Average loss: 2.8484
Iteration: 3177; Percent complete: 79.4%; Average loss: 2.8506
Iteration: 3178; Percent complete: 79.5%; Average loss: 2.9815
Iteration: 3179; Percent complete: 79.5%; Average loss: 3.1680
Iteration: 3180; Percent complete: 79.5%; Average loss: 2.8731
Iteration: 3181; Percent complete: 79.5%; Average loss: 2.7343
Iteration: 3182; Percent complete: 79.5%; Average loss: 2.6938
Iteration: 3183; Percent complete: 79.6%; Average loss: 2.9557
Iteration: 3184; Percent complete: 79.6%; Average loss: 2.9965
Iteration: 3185; Percent complete: 79.6%; Average loss: 3.1113
Iteration: 3186; Percent complete: 79.7%; Average loss: 2.7793
Iteration: 3187; Percent complete: 79.7%; Average loss: 2.8506
Iteration: 3188; Percent complete: 79.7%; Average loss: 2.8268
Iteration: 3189; Percent complete: 79.7%; Average loss: 3.0567
Iteration: 3190; Percent complete: 79.8%; Average loss: 2.7013
Iteration: 3191; Percent complete: 79.8%; Average loss: 2.9224
Iteration: 3192; Percent complete: 79.8%; Average loss: 2.6189
Iteration: 3193; Percent complete: 79.8%; Average loss: 2.5638
Iteration: 3194; Percent complete: 79.8%; Average loss: 2.9544
Iteration: 3195; Percent complete: 79.9%; Average loss: 2.9498
Iteration: 3196; Percent complete: 79.9%; Average loss: 2.7445
Iteration: 3197; Percent complete: 79.9%; Average loss: 2.8227
Iteration: 3198; Percent complete: 80.0%; Average loss: 3.0435
Iteration: 3199; Percent complete: 80.0%; Average loss: 3.1050
Iteration: 3200; Percent complete: 80.0%; Average loss: 2.8724
Iteration: 3201; Percent complete: 80.0%; Average loss: 2.8954
Iteration: 3202; Percent complete: 80.0%; Average loss: 2.6141
Iteration: 3203; Percent complete: 80.1%; Average loss: 2.6549
Iteration: 3204; Percent complete: 80.1%; Average loss: 2.7212
Iteration: 3205; Percent complete: 80.1%; Average loss: 2.9489
Iteration: 3206; Percent complete: 80.2%; Average loss: 2.5481
Iteration: 3207; Percent complete: 80.2%; Average loss: 2.9606
Iteration: 3208; Percent complete: 80.2%; Average loss: 2.7566
Iteration: 3209; Percent complete: 80.2%; Average loss: 2.8630
Iteration: 3210; Percent complete: 80.2%; Average loss: 2.9861
Iteration: 3211; Percent complete: 80.3%; Average loss: 2.5690
Iteration: 3212; Percent complete: 80.3%; Average loss: 2.8617
Iteration: 3213; Percent complete: 80.3%; Average loss: 2.6089
Iteration: 3214; Percent complete: 80.3%; Average loss: 2.7381
Iteration: 3215; Percent complete: 80.4%; Average loss: 2.5977
Iteration: 3216; Percent complete: 80.4%; Average loss: 2.9771
Iteration: 3217; Percent complete: 80.4%; Average loss: 2.7304
Iteration: 3218; Percent complete: 80.5%; Average loss: 2.7874
Iteration: 3219; Percent complete: 80.5%; Average loss: 2.7577
Iteration: 3220; Percent complete: 80.5%; Average loss: 2.8216
Iteration: 3221; Percent complete: 80.5%; Average loss: 3.1253
Iteration: 3222; Percent complete: 80.5%; Average loss: 2.6695
Iteration: 3223; Percent complete: 80.6%; Average loss: 3.0428
Iteration: 3224; Percent complete: 80.6%; Average loss: 3.0353
Iteration: 3225; Percent complete: 80.6%; Average loss: 2.7887
Iteration: 3226; Percent complete: 80.7%; Average loss: 2.9560
Iteration: 3227; Percent complete: 80.7%; Average loss: 2.7352
Iteration: 3228; Percent complete: 80.7%; Average loss: 2.7617
Iteration: 3229; Percent complete: 80.7%; Average loss: 3.0299
Iteration: 3230; Percent complete: 80.8%; Average loss: 2.8321
Iteration: 3231; Percent complete: 80.8%; Average loss: 2.7769
Iteration: 3232; Percent complete: 80.8%; Average loss: 2.9016
Iteration: 3233; Percent complete: 80.8%; Average loss: 3.0016
Iteration: 3234; Percent complete: 80.8%; Average loss: 2.6065
Iteration: 3235; Percent complete: 80.9%; Average loss: 2.9021
Iteration: 3236; Percent complete: 80.9%; Average loss: 2.9060
Iteration: 3237; Percent complete: 80.9%; Average loss: 2.8396
Iteration: 3238; Percent complete: 81.0%; Average loss: 2.6742
Iteration: 3239; Percent complete: 81.0%; Average loss: 2.8821
Iteration: 3240; Percent complete: 81.0%; Average loss: 2.7134
Iteration: 3241; Percent complete: 81.0%; Average loss: 2.9134
Iteration: 3242; Percent complete: 81.0%; Average loss: 2.8789
Iteration: 3243; Percent complete: 81.1%; Average loss: 2.8953
Iteration: 3244; Percent complete: 81.1%; Average loss: 2.6893
Iteration: 3245; Percent complete: 81.1%; Average loss: 2.7263
Iteration: 3246; Percent complete: 81.2%; Average loss: 2.8724
Iteration: 3247; Percent complete: 81.2%; Average loss: 2.9203
Iteration: 3248; Percent complete: 81.2%; Average loss: 2.7011
Iteration: 3249; Percent complete: 81.2%; Average loss: 2.9422
Iteration: 3250; Percent complete: 81.2%; Average loss: 2.7682
Iteration: 3251; Percent complete: 81.3%; Average loss: 2.8337
Iteration: 3252; Percent complete: 81.3%; Average loss: 2.8567
Iteration: 3253; Percent complete: 81.3%; Average loss: 2.6164
Iteration: 3254; Percent complete: 81.3%; Average loss: 2.8963
Iteration: 3255; Percent complete: 81.4%; Average loss: 2.9830
Iteration: 3256; Percent complete: 81.4%; Average loss: 3.1806
Iteration: 3257; Percent complete: 81.4%; Average loss: 2.7467
Iteration: 3258; Percent complete: 81.5%; Average loss: 2.8801
Iteration: 3259; Percent complete: 81.5%; Average loss: 2.8602
Iteration: 3260; Percent complete: 81.5%; Average loss: 3.1732
Iteration: 3261; Percent complete: 81.5%; Average loss: 2.7656
Iteration: 3262; Percent complete: 81.5%; Average loss: 2.5750
Iteration: 3263; Percent complete: 81.6%; Average loss: 2.7579
Iteration: 3264; Percent complete: 81.6%; Average loss: 2.9014
Iteration: 3265; Percent complete: 81.6%; Average loss: 2.7305
Iteration: 3266; Percent complete: 81.7%; Average loss: 2.6952
Iteration: 3267; Percent complete: 81.7%; Average loss: 2.7044
Iteration: 3268; Percent complete: 81.7%; Average loss: 2.7965
Iteration: 3269; Percent complete: 81.7%; Average loss: 2.7962
Iteration: 3270; Percent complete: 81.8%; Average loss: 2.8265
Iteration: 3271; Percent complete: 81.8%; Average loss: 2.8381
Iteration: 3272; Percent complete: 81.8%; Average loss: 2.8009
Iteration: 3273; Percent complete: 81.8%; Average loss: 2.7631
Iteration: 3274; Percent complete: 81.8%; Average loss: 2.6586
Iteration: 3275; Percent complete: 81.9%; Average loss: 2.9594
Iteration: 3276; Percent complete: 81.9%; Average loss: 2.9459
Iteration: 3277; Percent complete: 81.9%; Average loss: 2.8686
Iteration: 3278; Percent complete: 82.0%; Average loss: 2.8814
Iteration: 3279; Percent complete: 82.0%; Average loss: 2.7585
Iteration: 3280; Percent complete: 82.0%; Average loss: 2.8218
Iteration: 3281; Percent complete: 82.0%; Average loss: 2.7910
Iteration: 3282; Percent complete: 82.0%; Average loss: 2.9083
Iteration: 3283; Percent complete: 82.1%; Average loss: 2.8834
Iteration: 3284; Percent complete: 82.1%; Average loss: 2.7631
Iteration: 3285; Percent complete: 82.1%; Average loss: 3.0111
Iteration: 3286; Percent complete: 82.2%; Average loss: 2.8283
Iteration: 3287; Percent complete: 82.2%; Average loss: 2.7576
Iteration: 3288; Percent complete: 82.2%; Average loss: 2.7556
Iteration: 3289; Percent complete: 82.2%; Average loss: 2.8706
Iteration: 3290; Percent complete: 82.2%; Average loss: 3.0228
Iteration: 3291; Percent complete: 82.3%; Average loss: 2.7371
Iteration: 3292; Percent complete: 82.3%; Average loss: 2.6072
Iteration: 3293; Percent complete: 82.3%; Average loss: 2.8001
Iteration: 3294; Percent complete: 82.3%; Average loss: 2.6066
Iteration: 3295; Percent complete: 82.4%; Average loss: 2.8541
Iteration: 3296; Percent complete: 82.4%; Average loss: 2.7006
Iteration: 3297; Percent complete: 82.4%; Average loss: 2.9734
Iteration: 3298; Percent complete: 82.5%; Average loss: 2.8570
Iteration: 3299; Percent complete: 82.5%; Average loss: 2.7536
Iteration: 3300; Percent complete: 82.5%; Average loss: 2.8040
Iteration: 3301; Percent complete: 82.5%; Average loss: 2.6622
Iteration: 3302; Percent complete: 82.5%; Average loss: 2.9704
Iteration: 3303; Percent complete: 82.6%; Average loss: 2.7570
Iteration: 3304; Percent complete: 82.6%; Average loss: 2.9770
Iteration: 3305; Percent complete: 82.6%; Average loss: 3.0087
Iteration: 3306; Percent complete: 82.7%; Average loss: 2.7578
Iteration: 3307; Percent complete: 82.7%; Average loss: 2.8145
Iteration: 3308; Percent complete: 82.7%; Average loss: 2.9761
Iteration: 3309; Percent complete: 82.7%; Average loss: 2.7163
Iteration: 3310; Percent complete: 82.8%; Average loss: 3.0301
Iteration: 3311; Percent complete: 82.8%; Average loss: 2.7392
Iteration: 3312; Percent complete: 82.8%; Average loss: 2.7904
Iteration: 3313; Percent complete: 82.8%; Average loss: 2.8053
Iteration: 3314; Percent complete: 82.8%; Average loss: 2.8199
Iteration: 3315; Percent complete: 82.9%; Average loss: 2.9098
Iteration: 3316; Percent complete: 82.9%; Average loss: 2.7011
Iteration: 3317; Percent complete: 82.9%; Average loss: 2.6910
Iteration: 3318; Percent complete: 83.0%; Average loss: 2.8932
Iteration: 3319; Percent complete: 83.0%; Average loss: 2.7285
Iteration: 3320; Percent complete: 83.0%; Average loss: 2.8966
Iteration: 3321; Percent complete: 83.0%; Average loss: 2.9881
Iteration: 3322; Percent complete: 83.0%; Average loss: 2.8050
Iteration: 3323; Percent complete: 83.1%; Average loss: 2.6876
Iteration: 3324; Percent complete: 83.1%; Average loss: 2.6407
Iteration: 3325; Percent complete: 83.1%; Average loss: 2.8852
Iteration: 3326; Percent complete: 83.2%; Average loss: 2.9012
Iteration: 3327; Percent complete: 83.2%; Average loss: 2.6427
Iteration: 3328; Percent complete: 83.2%; Average loss: 2.7218
Iteration: 3329; Percent complete: 83.2%; Average loss: 2.8614
Iteration: 3330; Percent complete: 83.2%; Average loss: 2.8568
Iteration: 3331; Percent complete: 83.3%; Average loss: 2.9879
Iteration: 3332; Percent complete: 83.3%; Average loss: 2.7989
Iteration: 3333; Percent complete: 83.3%; Average loss: 2.6645
Iteration: 3334; Percent complete: 83.4%; Average loss: 2.7651
Iteration: 3335; Percent complete: 83.4%; Average loss: 2.6892
Iteration: 3336; Percent complete: 83.4%; Average loss: 2.6084
Iteration: 3337; Percent complete: 83.4%; Average loss: 2.7979
Iteration: 3338; Percent complete: 83.5%; Average loss: 2.7221
Iteration: 3339; Percent complete: 83.5%; Average loss: 2.7475
Iteration: 3340; Percent complete: 83.5%; Average loss: 2.8512
Iteration: 3341; Percent complete: 83.5%; Average loss: 2.7324
Iteration: 3342; Percent complete: 83.5%; Average loss: 2.8289
Iteration: 3343; Percent complete: 83.6%; Average loss: 2.5087
Iteration: 3344; Percent complete: 83.6%; Average loss: 2.8835
Iteration: 3345; Percent complete: 83.6%; Average loss: 3.0781
Iteration: 3346; Percent complete: 83.7%; Average loss: 3.0640
Iteration: 3347; Percent complete: 83.7%; Average loss: 2.6635
Iteration: 3348; Percent complete: 83.7%; Average loss: 2.7880
Iteration: 3349; Percent complete: 83.7%; Average loss: 2.7019
Iteration: 3350; Percent complete: 83.8%; Average loss: 2.7559
Iteration: 3351; Percent complete: 83.8%; Average loss: 2.8379
Iteration: 3352; Percent complete: 83.8%; Average loss: 2.7857
Iteration: 3353; Percent complete: 83.8%; Average loss: 2.6803
Iteration: 3354; Percent complete: 83.9%; Average loss: 2.8931
Iteration: 3355; Percent complete: 83.9%; Average loss: 2.8240
Iteration: 3356; Percent complete: 83.9%; Average loss: 2.9764
Iteration: 3357; Percent complete: 83.9%; Average loss: 2.8400
Iteration: 3358; Percent complete: 84.0%; Average loss: 2.7093
Iteration: 3359; Percent complete: 84.0%; Average loss: 2.9440
Iteration: 3360; Percent complete: 84.0%; Average loss: 2.9089
Iteration: 3361; Percent complete: 84.0%; Average loss: 2.6172
Iteration: 3362; Percent complete: 84.0%; Average loss: 2.9455
Iteration: 3363; Percent complete: 84.1%; Average loss: 3.0527
Iteration: 3364; Percent complete: 84.1%; Average loss: 2.7606
Iteration: 3365; Percent complete: 84.1%; Average loss: 2.9133
Iteration: 3366; Percent complete: 84.2%; Average loss: 2.8603
Iteration: 3367; Percent complete: 84.2%; Average loss: 2.7380
Iteration: 3368; Percent complete: 84.2%; Average loss: 2.9873
Iteration: 3369; Percent complete: 84.2%; Average loss: 3.1186
Iteration: 3370; Percent complete: 84.2%; Average loss: 2.8551
Iteration: 3371; Percent complete: 84.3%; Average loss: 2.8219
Iteration: 3372; Percent complete: 84.3%; Average loss: 2.7034
Iteration: 3373; Percent complete: 84.3%; Average loss: 2.6823
Iteration: 3374; Percent complete: 84.4%; Average loss: 2.8893
Iteration: 3375; Percent complete: 84.4%; Average loss: 2.7645
Iteration: 3376; Percent complete: 84.4%; Average loss: 2.7758
Iteration: 3377; Percent complete: 84.4%; Average loss: 2.6822
Iteration: 3378; Percent complete: 84.5%; Average loss: 2.7491
Iteration: 3379; Percent complete: 84.5%; Average loss: 2.9611
Iteration: 3380; Percent complete: 84.5%; Average loss: 2.9030
Iteration: 3381; Percent complete: 84.5%; Average loss: 2.8792
Iteration: 3382; Percent complete: 84.5%; Average loss: 2.9929
Iteration: 3383; Percent complete: 84.6%; Average loss: 2.8315
Iteration: 3384; Percent complete: 84.6%; Average loss: 2.9602
Iteration: 3385; Percent complete: 84.6%; Average loss: 2.6343
Iteration: 3386; Percent complete: 84.7%; Average loss: 2.3931
Iteration: 3387; Percent complete: 84.7%; Average loss: 2.8376
Iteration: 3388; Percent complete: 84.7%; Average loss: 2.5758
Iteration: 3389; Percent complete: 84.7%; Average loss: 2.8814
Iteration: 3390; Percent complete: 84.8%; Average loss: 2.6996
Iteration: 3391; Percent complete: 84.8%; Average loss: 2.8662
Iteration: 3392; Percent complete: 84.8%; Average loss: 2.6047
Iteration: 3393; Percent complete: 84.8%; Average loss: 2.7716
Iteration: 3394; Percent complete: 84.9%; Average loss: 2.4809
Iteration: 3395; Percent complete: 84.9%; Average loss: 2.5672
Iteration: 3396; Percent complete: 84.9%; Average loss: 2.9256
Iteration: 3397; Percent complete: 84.9%; Average loss: 2.8894
Iteration: 3398; Percent complete: 85.0%; Average loss: 2.8987
Iteration: 3399; Percent complete: 85.0%; Average loss: 2.6703
Iteration: 3400; Percent complete: 85.0%; Average loss: 2.7259
Iteration: 3401; Percent complete: 85.0%; Average loss: 3.1014
Iteration: 3402; Percent complete: 85.0%; Average loss: 2.6463
Iteration: 3403; Percent complete: 85.1%; Average loss: 2.6398
Iteration: 3404; Percent complete: 85.1%; Average loss: 2.7981
Iteration: 3405; Percent complete: 85.1%; Average loss: 2.8688
Iteration: 3406; Percent complete: 85.2%; Average loss: 2.9156
Iteration: 3407; Percent complete: 85.2%; Average loss: 2.7735
Iteration: 3408; Percent complete: 85.2%; Average loss: 2.9072
Iteration: 3409; Percent complete: 85.2%; Average loss: 2.5503
Iteration: 3410; Percent complete: 85.2%; Average loss: 2.7741
Iteration: 3411; Percent complete: 85.3%; Average loss: 2.6517
Iteration: 3412; Percent complete: 85.3%; Average loss: 2.8812
Iteration: 3413; Percent complete: 85.3%; Average loss: 2.8206
Iteration: 3414; Percent complete: 85.4%; Average loss: 2.7124
Iteration: 3415; Percent complete: 85.4%; Average loss: 2.5963
Iteration: 3416; Percent complete: 85.4%; Average loss: 2.7308
Iteration: 3417; Percent complete: 85.4%; Average loss: 2.5344
Iteration: 3418; Percent complete: 85.5%; Average loss: 2.7672
Iteration: 3419; Percent complete: 85.5%; Average loss: 2.7848
Iteration: 3420; Percent complete: 85.5%; Average loss: 2.8231
Iteration: 3421; Percent complete: 85.5%; Average loss: 2.7735
Iteration: 3422; Percent complete: 85.5%; Average loss: 2.7167
Iteration: 3423; Percent complete: 85.6%; Average loss: 2.6938
Iteration: 3424; Percent complete: 85.6%; Average loss: 2.9703
Iteration: 3425; Percent complete: 85.6%; Average loss: 2.7026
Iteration: 3426; Percent complete: 85.7%; Average loss: 2.7596
Iteration: 3427; Percent complete: 85.7%; Average loss: 2.6120
Iteration: 3428; Percent complete: 85.7%; Average loss: 2.6470
Iteration: 3429; Percent complete: 85.7%; Average loss: 2.7333
Iteration: 3430; Percent complete: 85.8%; Average loss: 2.6092
Iteration: 3431; Percent complete: 85.8%; Average loss: 2.8134
Iteration: 3432; Percent complete: 85.8%; Average loss: 2.7657
Iteration: 3433; Percent complete: 85.8%; Average loss: 3.0042
Iteration: 3434; Percent complete: 85.9%; Average loss: 2.9031
Iteration: 3435; Percent complete: 85.9%; Average loss: 2.8086
Iteration: 3436; Percent complete: 85.9%; Average loss: 2.7041
Iteration: 3437; Percent complete: 85.9%; Average loss: 2.8923
Iteration: 3438; Percent complete: 86.0%; Average loss: 2.8273
Iteration: 3439; Percent complete: 86.0%; Average loss: 2.8537
Iteration: 3440; Percent complete: 86.0%; Average loss: 2.7496
Iteration: 3441; Percent complete: 86.0%; Average loss: 2.8450
Iteration: 3442; Percent complete: 86.1%; Average loss: 2.9392
Iteration: 3443; Percent complete: 86.1%; Average loss: 3.0907
Iteration: 3444; Percent complete: 86.1%; Average loss: 2.6550
Iteration: 3445; Percent complete: 86.1%; Average loss: 2.8008
Iteration: 3446; Percent complete: 86.2%; Average loss: 2.5972
Iteration: 3447; Percent complete: 86.2%; Average loss: 2.8762
Iteration: 3448; Percent complete: 86.2%; Average loss: 2.6947
Iteration: 3449; Percent complete: 86.2%; Average loss: 3.1002
Iteration: 3450; Percent complete: 86.2%; Average loss: 2.7876
Iteration: 3451; Percent complete: 86.3%; Average loss: 2.7223
Iteration: 3452; Percent complete: 86.3%; Average loss: 3.1002
Iteration: 3453; Percent complete: 86.3%; Average loss: 2.6260
Iteration: 3454; Percent complete: 86.4%; Average loss: 2.5679
Iteration: 3455; Percent complete: 86.4%; Average loss: 2.8371
Iteration: 3456; Percent complete: 86.4%; Average loss: 2.7595
Iteration: 3457; Percent complete: 86.4%; Average loss: 2.8421
Iteration: 3458; Percent complete: 86.5%; Average loss: 2.8324
Iteration: 3459; Percent complete: 86.5%; Average loss: 2.5618
Iteration: 3460; Percent complete: 86.5%; Average loss: 2.7870
Iteration: 3461; Percent complete: 86.5%; Average loss: 3.0195
Iteration: 3462; Percent complete: 86.6%; Average loss: 2.9631
Iteration: 3463; Percent complete: 86.6%; Average loss: 2.7904
Iteration: 3464; Percent complete: 86.6%; Average loss: 2.7466
Iteration: 3465; Percent complete: 86.6%; Average loss: 3.0160
Iteration: 3466; Percent complete: 86.7%; Average loss: 2.6429
Iteration: 3467; Percent complete: 86.7%; Average loss: 2.8571
Iteration: 3468; Percent complete: 86.7%; Average loss: 2.8445
Iteration: 3469; Percent complete: 86.7%; Average loss: 2.6968
Iteration: 3470; Percent complete: 86.8%; Average loss: 2.7952
Iteration: 3471; Percent complete: 86.8%; Average loss: 2.7897
Iteration: 3472; Percent complete: 86.8%; Average loss: 2.6964
Iteration: 3473; Percent complete: 86.8%; Average loss: 2.6126
Iteration: 3474; Percent complete: 86.9%; Average loss: 2.9103
Iteration: 3475; Percent complete: 86.9%; Average loss: 2.8230
Iteration: 3476; Percent complete: 86.9%; Average loss: 2.7218
Iteration: 3477; Percent complete: 86.9%; Average loss: 2.7931
Iteration: 3478; Percent complete: 87.0%; Average loss: 2.8723
Iteration: 3479; Percent complete: 87.0%; Average loss: 2.7554
Iteration: 3480; Percent complete: 87.0%; Average loss: 2.6502
Iteration: 3481; Percent complete: 87.0%; Average loss: 2.8070
Iteration: 3482; Percent complete: 87.1%; Average loss: 2.7118
Iteration: 3483; Percent complete: 87.1%; Average loss: 2.9012
Iteration: 3484; Percent complete: 87.1%; Average loss: 2.7519
Iteration: 3485; Percent complete: 87.1%; Average loss: 2.6740
Iteration: 3486; Percent complete: 87.2%; Average loss: 2.6443
Iteration: 3487; Percent complete: 87.2%; Average loss: 2.6053
Iteration: 3488; Percent complete: 87.2%; Average loss: 2.7751
Iteration: 3489; Percent complete: 87.2%; Average loss: 2.7651
Iteration: 3490; Percent complete: 87.2%; Average loss: 2.5594
Iteration: 3491; Percent complete: 87.3%; Average loss: 2.7798
Iteration: 3492; Percent complete: 87.3%; Average loss: 2.8957
Iteration: 3493; Percent complete: 87.3%; Average loss: 2.7010
Iteration: 3494; Percent complete: 87.4%; Average loss: 2.8322
Iteration: 3495; Percent complete: 87.4%; Average loss: 3.0085
Iteration: 3496; Percent complete: 87.4%; Average loss: 2.8571
Iteration: 3497; Percent complete: 87.4%; Average loss: 2.8022
Iteration: 3498; Percent complete: 87.5%; Average loss: 2.9035
Iteration: 3499; Percent complete: 87.5%; Average loss: 2.8653
Iteration: 3500; Percent complete: 87.5%; Average loss: 2.9338
Iteration: 3501; Percent complete: 87.5%; Average loss: 2.6978
Iteration: 3502; Percent complete: 87.5%; Average loss: 3.0126
Iteration: 3503; Percent complete: 87.6%; Average loss: 2.6614
Iteration: 3504; Percent complete: 87.6%; Average loss: 2.7509
Iteration: 3505; Percent complete: 87.6%; Average loss: 2.8966
Iteration: 3506; Percent complete: 87.6%; Average loss: 2.8227
Iteration: 3507; Percent complete: 87.7%; Average loss: 2.9407
Iteration: 3508; Percent complete: 87.7%; Average loss: 2.6397
Iteration: 3509; Percent complete: 87.7%; Average loss: 2.7439
Iteration: 3510; Percent complete: 87.8%; Average loss: 2.5785
Iteration: 3511; Percent complete: 87.8%; Average loss: 2.6499
Iteration: 3512; Percent complete: 87.8%; Average loss: 2.8389
Iteration: 3513; Percent complete: 87.8%; Average loss: 2.8240
Iteration: 3514; Percent complete: 87.8%; Average loss: 2.6366
Iteration: 3515; Percent complete: 87.9%; Average loss: 2.7338
Iteration: 3516; Percent complete: 87.9%; Average loss: 2.7163
Iteration: 3517; Percent complete: 87.9%; Average loss: 2.5776
Iteration: 3518; Percent complete: 87.9%; Average loss: 2.8317
Iteration: 3519; Percent complete: 88.0%; Average loss: 2.9854
Iteration: 3520; Percent complete: 88.0%; Average loss: 2.9861
Iteration: 3521; Percent complete: 88.0%; Average loss: 2.8569
Iteration: 3522; Percent complete: 88.0%; Average loss: 2.9599
Iteration: 3523; Percent complete: 88.1%; Average loss: 2.7958
Iteration: 3524; Percent complete: 88.1%; Average loss: 2.6333
Iteration: 3525; Percent complete: 88.1%; Average loss: 2.9367
Iteration: 3526; Percent complete: 88.1%; Average loss: 2.7724
Iteration: 3527; Percent complete: 88.2%; Average loss: 2.6288
Iteration: 3528; Percent complete: 88.2%; Average loss: 2.7808
Iteration: 3529; Percent complete: 88.2%; Average loss: 2.7525
Iteration: 3530; Percent complete: 88.2%; Average loss: 2.8731
Iteration: 3531; Percent complete: 88.3%; Average loss: 2.9023
Iteration: 3532; Percent complete: 88.3%; Average loss: 2.6485
Iteration: 3533; Percent complete: 88.3%; Average loss: 2.6218
Iteration: 3534; Percent complete: 88.3%; Average loss: 2.8363
Iteration: 3535; Percent complete: 88.4%; Average loss: 2.6282
Iteration: 3536; Percent complete: 88.4%; Average loss: 2.9439
Iteration: 3537; Percent complete: 88.4%; Average loss: 2.8652
Iteration: 3538; Percent complete: 88.4%; Average loss: 2.7664
Iteration: 3539; Percent complete: 88.5%; Average loss: 2.7349
Iteration: 3540; Percent complete: 88.5%; Average loss: 2.7351
Iteration: 3541; Percent complete: 88.5%; Average loss: 2.7811
Iteration: 3542; Percent complete: 88.5%; Average loss: 2.6723
Iteration: 3543; Percent complete: 88.6%; Average loss: 2.9003
Iteration: 3544; Percent complete: 88.6%; Average loss: 2.5459
Iteration: 3545; Percent complete: 88.6%; Average loss: 2.4747
Iteration: 3546; Percent complete: 88.6%; Average loss: 2.8357
Iteration: 3547; Percent complete: 88.7%; Average loss: 2.8495
Iteration: 3548; Percent complete: 88.7%; Average loss: 2.7498
Iteration: 3549; Percent complete: 88.7%; Average loss: 2.4550
Iteration: 3550; Percent complete: 88.8%; Average loss: 2.7671
Iteration: 3551; Percent complete: 88.8%; Average loss: 2.7142
Iteration: 3552; Percent complete: 88.8%; Average loss: 2.8500
Iteration: 3553; Percent complete: 88.8%; Average loss: 2.4096
Iteration: 3554; Percent complete: 88.8%; Average loss: 2.6387
Iteration: 3555; Percent complete: 88.9%; Average loss: 2.8062
Iteration: 3556; Percent complete: 88.9%; Average loss: 2.6289
Iteration: 3557; Percent complete: 88.9%; Average loss: 2.7074
Iteration: 3558; Percent complete: 88.9%; Average loss: 2.6589
Iteration: 3559; Percent complete: 89.0%; Average loss: 2.7646
Iteration: 3560; Percent complete: 89.0%; Average loss: 2.6523
Iteration: 3561; Percent complete: 89.0%; Average loss: 2.3769
Iteration: 3562; Percent complete: 89.0%; Average loss: 2.8390
Iteration: 3563; Percent complete: 89.1%; Average loss: 2.6592
Iteration: 3564; Percent complete: 89.1%; Average loss: 2.8387
Iteration: 3565; Percent complete: 89.1%; Average loss: 2.6988
Iteration: 3566; Percent complete: 89.1%; Average loss: 2.7358
Iteration: 3567; Percent complete: 89.2%; Average loss: 2.7807
Iteration: 3568; Percent complete: 89.2%; Average loss: 2.7783
Iteration: 3569; Percent complete: 89.2%; Average loss: 2.7017
Iteration: 3570; Percent complete: 89.2%; Average loss: 2.9106
Iteration: 3571; Percent complete: 89.3%; Average loss: 2.9037
Iteration: 3572; Percent complete: 89.3%; Average loss: 2.6767
Iteration: 3573; Percent complete: 89.3%; Average loss: 2.7817
Iteration: 3574; Percent complete: 89.3%; Average loss: 2.4608
Iteration: 3575; Percent complete: 89.4%; Average loss: 2.7522
Iteration: 3576; Percent complete: 89.4%; Average loss: 2.7644
Iteration: 3577; Percent complete: 89.4%; Average loss: 2.8274
Iteration: 3578; Percent complete: 89.5%; Average loss: 2.6734
Iteration: 3579; Percent complete: 89.5%; Average loss: 2.7821
Iteration: 3580; Percent complete: 89.5%; Average loss: 2.7247
Iteration: 3581; Percent complete: 89.5%; Average loss: 2.5095
Iteration: 3582; Percent complete: 89.5%; Average loss: 2.7302
Iteration: 3583; Percent complete: 89.6%; Average loss: 2.7604
Iteration: 3584; Percent complete: 89.6%; Average loss: 2.8488
Iteration: 3585; Percent complete: 89.6%; Average loss: 2.6055
Iteration: 3586; Percent complete: 89.6%; Average loss: 2.9103
Iteration: 3587; Percent complete: 89.7%; Average loss: 2.5486
Iteration: 3588; Percent complete: 89.7%; Average loss: 2.7134
Iteration: 3589; Percent complete: 89.7%; Average loss: 2.6572
Iteration: 3590; Percent complete: 89.8%; Average loss: 2.5271
Iteration: 3591; Percent complete: 89.8%; Average loss: 2.8715
Iteration: 3592; Percent complete: 89.8%; Average loss: 2.6987
Iteration: 3593; Percent complete: 89.8%; Average loss: 2.6385
Iteration: 3594; Percent complete: 89.8%; Average loss: 2.9809
Iteration: 3595; Percent complete: 89.9%; Average loss: 2.5346
Iteration: 3596; Percent complete: 89.9%; Average loss: 2.7642
Iteration: 3597; Percent complete: 89.9%; Average loss: 2.9709
Iteration: 3598; Percent complete: 90.0%; Average loss: 2.7406
Iteration: 3599; Percent complete: 90.0%; Average loss: 2.8136
Iteration: 3600; Percent complete: 90.0%; Average loss: 2.7403
Iteration: 3601; Percent complete: 90.0%; Average loss: 2.6201
Iteration: 3602; Percent complete: 90.0%; Average loss: 2.7485
Iteration: 3603; Percent complete: 90.1%; Average loss: 2.6372
Iteration: 3604; Percent complete: 90.1%; Average loss: 2.9056
Iteration: 3605; Percent complete: 90.1%; Average loss: 2.6766
Iteration: 3606; Percent complete: 90.1%; Average loss: 2.6462
Iteration: 3607; Percent complete: 90.2%; Average loss: 2.8606
Iteration: 3608; Percent complete: 90.2%; Average loss: 2.7513
Iteration: 3609; Percent complete: 90.2%; Average loss: 2.7384
Iteration: 3610; Percent complete: 90.2%; Average loss: 2.7199
Iteration: 3611; Percent complete: 90.3%; Average loss: 2.8830
Iteration: 3612; Percent complete: 90.3%; Average loss: 2.8951
Iteration: 3613; Percent complete: 90.3%; Average loss: 2.9171
Iteration: 3614; Percent complete: 90.3%; Average loss: 2.7899
Iteration: 3615; Percent complete: 90.4%; Average loss: 2.7406
Iteration: 3616; Percent complete: 90.4%; Average loss: 2.7438
Iteration: 3617; Percent complete: 90.4%; Average loss: 2.5960
Iteration: 3618; Percent complete: 90.5%; Average loss: 2.8220
Iteration: 3619; Percent complete: 90.5%; Average loss: 2.7859
Iteration: 3620; Percent complete: 90.5%; Average loss: 2.8282
Iteration: 3621; Percent complete: 90.5%; Average loss: 2.8052
Iteration: 3622; Percent complete: 90.5%; Average loss: 2.7802
Iteration: 3623; Percent complete: 90.6%; Average loss: 2.5426
Iteration: 3624; Percent complete: 90.6%; Average loss: 2.4947
Iteration: 3625; Percent complete: 90.6%; Average loss: 2.6083
Iteration: 3626; Percent complete: 90.6%; Average loss: 2.7936
Iteration: 3627; Percent complete: 90.7%; Average loss: 2.7624
Iteration: 3628; Percent complete: 90.7%; Average loss: 2.7565
Iteration: 3629; Percent complete: 90.7%; Average loss: 2.5188
Iteration: 3630; Percent complete: 90.8%; Average loss: 2.7671
Iteration: 3631; Percent complete: 90.8%; Average loss: 2.5829
Iteration: 3632; Percent complete: 90.8%; Average loss: 2.8953
Iteration: 3633; Percent complete: 90.8%; Average loss: 2.5587
Iteration: 3634; Percent complete: 90.8%; Average loss: 2.4599
Iteration: 3635; Percent complete: 90.9%; Average loss: 2.7809
Iteration: 3636; Percent complete: 90.9%; Average loss: 2.7381
Iteration: 3637; Percent complete: 90.9%; Average loss: 2.8912
Iteration: 3638; Percent complete: 91.0%; Average loss: 2.9653
Iteration: 3639; Percent complete: 91.0%; Average loss: 2.5857
Iteration: 3640; Percent complete: 91.0%; Average loss: 2.5667
Iteration: 3641; Percent complete: 91.0%; Average loss: 2.6367
Iteration: 3642; Percent complete: 91.0%; Average loss: 2.9579
Iteration: 3643; Percent complete: 91.1%; Average loss: 2.4914
Iteration: 3644; Percent complete: 91.1%; Average loss: 2.6543
Iteration: 3645; Percent complete: 91.1%; Average loss: 2.6592
Iteration: 3646; Percent complete: 91.1%; Average loss: 2.7719
Iteration: 3647; Percent complete: 91.2%; Average loss: 2.8179
Iteration: 3648; Percent complete: 91.2%; Average loss: 2.6977
Iteration: 3649; Percent complete: 91.2%; Average loss: 2.8263
Iteration: 3650; Percent complete: 91.2%; Average loss: 2.8187
Iteration: 3651; Percent complete: 91.3%; Average loss: 2.8211
Iteration: 3652; Percent complete: 91.3%; Average loss: 2.7797
Iteration: 3653; Percent complete: 91.3%; Average loss: 2.4262
Iteration: 3654; Percent complete: 91.3%; Average loss: 2.6915
Iteration: 3655; Percent complete: 91.4%; Average loss: 2.6853
Iteration: 3656; Percent complete: 91.4%; Average loss: 2.6339
Iteration: 3657; Percent complete: 91.4%; Average loss: 2.8111
Iteration: 3658; Percent complete: 91.5%; Average loss: 2.6490
Iteration: 3659; Percent complete: 91.5%; Average loss: 2.9375
Iteration: 3660; Percent complete: 91.5%; Average loss: 2.5154
Iteration: 3661; Percent complete: 91.5%; Average loss: 2.8705
Iteration: 3662; Percent complete: 91.5%; Average loss: 2.6436
Iteration: 3663; Percent complete: 91.6%; Average loss: 2.9609
Iteration: 3664; Percent complete: 91.6%; Average loss: 2.9305
Iteration: 3665; Percent complete: 91.6%; Average loss: 2.7035
Iteration: 3666; Percent complete: 91.6%; Average loss: 2.5411
Iteration: 3667; Percent complete: 91.7%; Average loss: 2.7235
Iteration: 3668; Percent complete: 91.7%; Average loss: 2.7632
Iteration: 3669; Percent complete: 91.7%; Average loss: 3.0308
Iteration: 3670; Percent complete: 91.8%; Average loss: 2.7461
Iteration: 3671; Percent complete: 91.8%; Average loss: 2.7510
Iteration: 3672; Percent complete: 91.8%; Average loss: 2.7966
Iteration: 3673; Percent complete: 91.8%; Average loss: 2.9226
Iteration: 3674; Percent complete: 91.8%; Average loss: 2.7777
Iteration: 3675; Percent complete: 91.9%; Average loss: 2.7788
Iteration: 3676; Percent complete: 91.9%; Average loss: 2.7689
Iteration: 3677; Percent complete: 91.9%; Average loss: 2.7002
Iteration: 3678; Percent complete: 92.0%; Average loss: 2.5962
Iteration: 3679; Percent complete: 92.0%; Average loss: 2.5871
Iteration: 3680; Percent complete: 92.0%; Average loss: 2.7240
Iteration: 3681; Percent complete: 92.0%; Average loss: 2.6604
Iteration: 3682; Percent complete: 92.0%; Average loss: 2.8779
Iteration: 3683; Percent complete: 92.1%; Average loss: 2.6837
Iteration: 3684; Percent complete: 92.1%; Average loss: 2.5721
Iteration: 3685; Percent complete: 92.1%; Average loss: 2.6857
Iteration: 3686; Percent complete: 92.2%; Average loss: 2.6625
Iteration: 3687; Percent complete: 92.2%; Average loss: 2.8683
Iteration: 3688; Percent complete: 92.2%; Average loss: 2.9017
Iteration: 3689; Percent complete: 92.2%; Average loss: 2.6607
Iteration: 3690; Percent complete: 92.2%; Average loss: 2.7443
Iteration: 3691; Percent complete: 92.3%; Average loss: 2.8769
Iteration: 3692; Percent complete: 92.3%; Average loss: 2.5687
Iteration: 3693; Percent complete: 92.3%; Average loss: 2.8100
Iteration: 3694; Percent complete: 92.3%; Average loss: 2.9361
Iteration: 3695; Percent complete: 92.4%; Average loss: 2.7577
Iteration: 3696; Percent complete: 92.4%; Average loss: 2.7881
Iteration: 3697; Percent complete: 92.4%; Average loss: 2.6007
Iteration: 3698; Percent complete: 92.5%; Average loss: 2.7341
Iteration: 3699; Percent complete: 92.5%; Average loss: 2.7755
Iteration: 3700; Percent complete: 92.5%; Average loss: 2.6478
Iteration: 3701; Percent complete: 92.5%; Average loss: 2.7628
Iteration: 3702; Percent complete: 92.5%; Average loss: 2.5504
Iteration: 3703; Percent complete: 92.6%; Average loss: 2.5120
Iteration: 3704; Percent complete: 92.6%; Average loss: 2.4669
Iteration: 3705; Percent complete: 92.6%; Average loss: 2.7102
Iteration: 3706; Percent complete: 92.7%; Average loss: 2.8169
Iteration: 3707; Percent complete: 92.7%; Average loss: 2.5761
Iteration: 3708; Percent complete: 92.7%; Average loss: 2.6295
Iteration: 3709; Percent complete: 92.7%; Average loss: 2.7183
Iteration: 3710; Percent complete: 92.8%; Average loss: 2.5386
Iteration: 3711; Percent complete: 92.8%; Average loss: 2.7696
Iteration: 3712; Percent complete: 92.8%; Average loss: 2.5992
Iteration: 3713; Percent complete: 92.8%; Average loss: 2.5058
Iteration: 3714; Percent complete: 92.8%; Average loss: 2.6852
Iteration: 3715; Percent complete: 92.9%; Average loss: 2.7969
Iteration: 3716; Percent complete: 92.9%; Average loss: 2.6139
Iteration: 3717; Percent complete: 92.9%; Average loss: 2.5632
Iteration: 3718; Percent complete: 93.0%; Average loss: 2.7006
Iteration: 3719; Percent complete: 93.0%; Average loss: 2.5219
Iteration: 3720; Percent complete: 93.0%; Average loss: 2.6465
Iteration: 3721; Percent complete: 93.0%; Average loss: 2.9065
Iteration: 3722; Percent complete: 93.0%; Average loss: 2.7161
Iteration: 3723; Percent complete: 93.1%; Average loss: 2.8801
Iteration: 3724; Percent complete: 93.1%; Average loss: 2.7236
Iteration: 3725; Percent complete: 93.1%; Average loss: 2.8996
Iteration: 3726; Percent complete: 93.2%; Average loss: 2.8823
Iteration: 3727; Percent complete: 93.2%; Average loss: 2.7951
Iteration: 3728; Percent complete: 93.2%; Average loss: 2.7096
Iteration: 3729; Percent complete: 93.2%; Average loss: 2.7545
Iteration: 3730; Percent complete: 93.2%; Average loss: 2.6387
Iteration: 3731; Percent complete: 93.3%; Average loss: 2.7891
Iteration: 3732; Percent complete: 93.3%; Average loss: 2.8842
Iteration: 3733; Percent complete: 93.3%; Average loss: 2.7891
Iteration: 3734; Percent complete: 93.3%; Average loss: 2.7105
Iteration: 3735; Percent complete: 93.4%; Average loss: 2.4394
Iteration: 3736; Percent complete: 93.4%; Average loss: 2.6228
Iteration: 3737; Percent complete: 93.4%; Average loss: 2.6867
Iteration: 3738; Percent complete: 93.5%; Average loss: 2.8196
Iteration: 3739; Percent complete: 93.5%; Average loss: 2.7352
Iteration: 3740; Percent complete: 93.5%; Average loss: 2.5552
Iteration: 3741; Percent complete: 93.5%; Average loss: 2.6294
Iteration: 3742; Percent complete: 93.5%; Average loss: 2.5188
Iteration: 3743; Percent complete: 93.6%; Average loss: 2.6092
Iteration: 3744; Percent complete: 93.6%; Average loss: 2.6712
Iteration: 3745; Percent complete: 93.6%; Average loss: 2.4520
Iteration: 3746; Percent complete: 93.7%; Average loss: 2.8120
Iteration: 3747; Percent complete: 93.7%; Average loss: 2.7686
Iteration: 3748; Percent complete: 93.7%; Average loss: 2.5964
Iteration: 3749; Percent complete: 93.7%; Average loss: 2.6985
Iteration: 3750; Percent complete: 93.8%; Average loss: 2.6763
Iteration: 3751; Percent complete: 93.8%; Average loss: 2.6378
Iteration: 3752; Percent complete: 93.8%; Average loss: 2.5708
Iteration: 3753; Percent complete: 93.8%; Average loss: 2.8661
Iteration: 3754; Percent complete: 93.8%; Average loss: 2.6351
Iteration: 3755; Percent complete: 93.9%; Average loss: 2.6369
Iteration: 3756; Percent complete: 93.9%; Average loss: 2.7530
Iteration: 3757; Percent complete: 93.9%; Average loss: 2.8063
Iteration: 3758; Percent complete: 94.0%; Average loss: 2.6893
Iteration: 3759; Percent complete: 94.0%; Average loss: 2.4340
Iteration: 3760; Percent complete: 94.0%; Average loss: 2.7338
Iteration: 3761; Percent complete: 94.0%; Average loss: 2.7325
Iteration: 3762; Percent complete: 94.0%; Average loss: 2.5482
Iteration: 3763; Percent complete: 94.1%; Average loss: 2.6697
Iteration: 3764; Percent complete: 94.1%; Average loss: 2.8110
Iteration: 3765; Percent complete: 94.1%; Average loss: 2.4770
Iteration: 3766; Percent complete: 94.2%; Average loss: 2.5957
Iteration: 3767; Percent complete: 94.2%; Average loss: 2.5597
Iteration: 3768; Percent complete: 94.2%; Average loss: 2.5163
Iteration: 3769; Percent complete: 94.2%; Average loss: 2.5935
Iteration: 3770; Percent complete: 94.2%; Average loss: 2.6926
Iteration: 3771; Percent complete: 94.3%; Average loss: 2.6880
Iteration: 3772; Percent complete: 94.3%; Average loss: 2.9290
Iteration: 3773; Percent complete: 94.3%; Average loss: 2.8472
Iteration: 3774; Percent complete: 94.3%; Average loss: 2.5099
Iteration: 3775; Percent complete: 94.4%; Average loss: 2.6725
Iteration: 3776; Percent complete: 94.4%; Average loss: 2.8390
Iteration: 3777; Percent complete: 94.4%; Average loss: 2.7888
Iteration: 3778; Percent complete: 94.5%; Average loss: 2.7204
Iteration: 3779; Percent complete: 94.5%; Average loss: 2.4501
Iteration: 3780; Percent complete: 94.5%; Average loss: 2.6347
Iteration: 3781; Percent complete: 94.5%; Average loss: 2.5698
Iteration: 3782; Percent complete: 94.5%; Average loss: 2.7672
Iteration: 3783; Percent complete: 94.6%; Average loss: 2.8331
Iteration: 3784; Percent complete: 94.6%; Average loss: 2.7519
Iteration: 3785; Percent complete: 94.6%; Average loss: 2.8549
Iteration: 3786; Percent complete: 94.7%; Average loss: 2.6265
Iteration: 3787; Percent complete: 94.7%; Average loss: 2.7046
Iteration: 3788; Percent complete: 94.7%; Average loss: 2.6728
Iteration: 3789; Percent complete: 94.7%; Average loss: 2.5434
Iteration: 3790; Percent complete: 94.8%; Average loss: 2.8013
Iteration: 3791; Percent complete: 94.8%; Average loss: 2.8715
Iteration: 3792; Percent complete: 94.8%; Average loss: 2.6730
Iteration: 3793; Percent complete: 94.8%; Average loss: 2.6423
Iteration: 3794; Percent complete: 94.8%; Average loss: 2.8039
Iteration: 3795; Percent complete: 94.9%; Average loss: 2.5552
Iteration: 3796; Percent complete: 94.9%; Average loss: 2.6990
Iteration: 3797; Percent complete: 94.9%; Average loss: 2.6548
Iteration: 3798; Percent complete: 95.0%; Average loss: 2.7327
Iteration: 3799; Percent complete: 95.0%; Average loss: 2.5421
Iteration: 3800; Percent complete: 95.0%; Average loss: 2.6362
Iteration: 3801; Percent complete: 95.0%; Average loss: 2.8059
Iteration: 3802; Percent complete: 95.0%; Average loss: 2.6334
Iteration: 3803; Percent complete: 95.1%; Average loss: 2.8034
Iteration: 3804; Percent complete: 95.1%; Average loss: 2.8208
Iteration: 3805; Percent complete: 95.1%; Average loss: 2.7037
Iteration: 3806; Percent complete: 95.2%; Average loss: 2.6379
Iteration: 3807; Percent complete: 95.2%; Average loss: 2.6256
Iteration: 3808; Percent complete: 95.2%; Average loss: 2.5928
Iteration: 3809; Percent complete: 95.2%; Average loss: 2.6718
Iteration: 3810; Percent complete: 95.2%; Average loss: 2.4312
Iteration: 3811; Percent complete: 95.3%; Average loss: 2.9006
Iteration: 3812; Percent complete: 95.3%; Average loss: 2.6218
Iteration: 3813; Percent complete: 95.3%; Average loss: 2.5679
Iteration: 3814; Percent complete: 95.3%; Average loss: 2.6689
Iteration: 3815; Percent complete: 95.4%; Average loss: 2.8886
Iteration: 3816; Percent complete: 95.4%; Average loss: 2.8269
Iteration: 3817; Percent complete: 95.4%; Average loss: 2.6144
Iteration: 3818; Percent complete: 95.5%; Average loss: 2.5663
Iteration: 3819; Percent complete: 95.5%; Average loss: 2.3637
Iteration: 3820; Percent complete: 95.5%; Average loss: 2.7378
Iteration: 3821; Percent complete: 95.5%; Average loss: 2.6311
Iteration: 3822; Percent complete: 95.5%; Average loss: 2.5954
Iteration: 3823; Percent complete: 95.6%; Average loss: 2.8508
Iteration: 3824; Percent complete: 95.6%; Average loss: 2.5465
Iteration: 3825; Percent complete: 95.6%; Average loss: 2.6496
Iteration: 3826; Percent complete: 95.7%; Average loss: 2.6587
Iteration: 3827; Percent complete: 95.7%; Average loss: 2.6827
Iteration: 3828; Percent complete: 95.7%; Average loss: 2.6043
Iteration: 3829; Percent complete: 95.7%; Average loss: 2.5903
Iteration: 3830; Percent complete: 95.8%; Average loss: 2.3748
Iteration: 3831; Percent complete: 95.8%; Average loss: 2.7113
Iteration: 3832; Percent complete: 95.8%; Average loss: 2.6782
Iteration: 3833; Percent complete: 95.8%; Average loss: 2.7212
Iteration: 3834; Percent complete: 95.9%; Average loss: 2.6919
Iteration: 3835; Percent complete: 95.9%; Average loss: 2.7543
Iteration: 3836; Percent complete: 95.9%; Average loss: 2.8157
Iteration: 3837; Percent complete: 95.9%; Average loss: 2.6383
Iteration: 3838; Percent complete: 96.0%; Average loss: 2.4054
Iteration: 3839; Percent complete: 96.0%; Average loss: 2.5669
Iteration: 3840; Percent complete: 96.0%; Average loss: 2.5923
Iteration: 3841; Percent complete: 96.0%; Average loss: 2.4748
Iteration: 3842; Percent complete: 96.0%; Average loss: 2.5132
Iteration: 3843; Percent complete: 96.1%; Average loss: 2.5114
Iteration: 3844; Percent complete: 96.1%; Average loss: 2.6642
Iteration: 3845; Percent complete: 96.1%; Average loss: 2.6012
Iteration: 3846; Percent complete: 96.2%; Average loss: 2.5979
Iteration: 3847; Percent complete: 96.2%; Average loss: 2.5810
Iteration: 3848; Percent complete: 96.2%; Average loss: 2.6414
Iteration: 3849; Percent complete: 96.2%; Average loss: 2.6151
Iteration: 3850; Percent complete: 96.2%; Average loss: 2.7355
Iteration: 3851; Percent complete: 96.3%; Average loss: 2.6612
Iteration: 3852; Percent complete: 96.3%; Average loss: 2.6712
Iteration: 3853; Percent complete: 96.3%; Average loss: 2.5384
Iteration: 3854; Percent complete: 96.4%; Average loss: 2.5040
Iteration: 3855; Percent complete: 96.4%; Average loss: 2.5397
Iteration: 3856; Percent complete: 96.4%; Average loss: 2.7962
Iteration: 3857; Percent complete: 96.4%; Average loss: 2.7797
Iteration: 3858; Percent complete: 96.5%; Average loss: 2.5411
Iteration: 3859; Percent complete: 96.5%; Average loss: 2.6960
Iteration: 3860; Percent complete: 96.5%; Average loss: 2.7337
Iteration: 3861; Percent complete: 96.5%; Average loss: 2.6904
Iteration: 3862; Percent complete: 96.5%; Average loss: 2.4760
Iteration: 3863; Percent complete: 96.6%; Average loss: 2.7493
Iteration: 3864; Percent complete: 96.6%; Average loss: 2.3869
Iteration: 3865; Percent complete: 96.6%; Average loss: 2.8992
Iteration: 3866; Percent complete: 96.7%; Average loss: 2.7616
Iteration: 3867; Percent complete: 96.7%; Average loss: 2.7754
Iteration: 3868; Percent complete: 96.7%; Average loss: 2.5131
Iteration: 3869; Percent complete: 96.7%; Average loss: 2.6452
Iteration: 3870; Percent complete: 96.8%; Average loss: 2.8807
Iteration: 3871; Percent complete: 96.8%; Average loss: 2.8873
Iteration: 3872; Percent complete: 96.8%; Average loss: 2.6848
Iteration: 3873; Percent complete: 96.8%; Average loss: 2.5844
Iteration: 3874; Percent complete: 96.9%; Average loss: 2.7013
Iteration: 3875; Percent complete: 96.9%; Average loss: 2.8438
Iteration: 3876; Percent complete: 96.9%; Average loss: 2.7283
Iteration: 3877; Percent complete: 96.9%; Average loss: 2.6320
Iteration: 3878; Percent complete: 97.0%; Average loss: 2.5238
Iteration: 3879; Percent complete: 97.0%; Average loss: 2.7236
Iteration: 3880; Percent complete: 97.0%; Average loss: 2.4119
Iteration: 3881; Percent complete: 97.0%; Average loss: 2.7723
Iteration: 3882; Percent complete: 97.0%; Average loss: 2.6415
Iteration: 3883; Percent complete: 97.1%; Average loss: 2.7264
Iteration: 3884; Percent complete: 97.1%; Average loss: 2.7873
Iteration: 3885; Percent complete: 97.1%; Average loss: 2.5144
Iteration: 3886; Percent complete: 97.2%; Average loss: 2.7367
Iteration: 3887; Percent complete: 97.2%; Average loss: 2.5635
Iteration: 3888; Percent complete: 97.2%; Average loss: 2.6472
Iteration: 3889; Percent complete: 97.2%; Average loss: 2.6999
Iteration: 3890; Percent complete: 97.2%; Average loss: 2.7171
Iteration: 3891; Percent complete: 97.3%; Average loss: 2.8588
Iteration: 3892; Percent complete: 97.3%; Average loss: 2.6317
Iteration: 3893; Percent complete: 97.3%; Average loss: 2.7523
Iteration: 3894; Percent complete: 97.4%; Average loss: 2.8535
Iteration: 3895; Percent complete: 97.4%; Average loss: 2.8934
Iteration: 3896; Percent complete: 97.4%; Average loss: 2.8214
Iteration: 3897; Percent complete: 97.4%; Average loss: 2.5518
Iteration: 3898; Percent complete: 97.5%; Average loss: 2.6113
Iteration: 3899; Percent complete: 97.5%; Average loss: 2.7336
Iteration: 3900; Percent complete: 97.5%; Average loss: 2.7150
Iteration: 3901; Percent complete: 97.5%; Average loss: 2.6257
Iteration: 3902; Percent complete: 97.5%; Average loss: 2.5650
Iteration: 3903; Percent complete: 97.6%; Average loss: 2.5366
Iteration: 3904; Percent complete: 97.6%; Average loss: 2.5825
Iteration: 3905; Percent complete: 97.6%; Average loss: 2.7564
Iteration: 3906; Percent complete: 97.7%; Average loss: 2.5908
Iteration: 3907; Percent complete: 97.7%; Average loss: 2.4846
Iteration: 3908; Percent complete: 97.7%; Average loss: 2.7238
Iteration: 3909; Percent complete: 97.7%; Average loss: 2.7918
Iteration: 3910; Percent complete: 97.8%; Average loss: 2.6161
Iteration: 3911; Percent complete: 97.8%; Average loss: 2.5231
Iteration: 3912; Percent complete: 97.8%; Average loss: 2.4391
Iteration: 3913; Percent complete: 97.8%; Average loss: 2.6496
Iteration: 3914; Percent complete: 97.9%; Average loss: 2.7394
Iteration: 3915; Percent complete: 97.9%; Average loss: 2.5807
Iteration: 3916; Percent complete: 97.9%; Average loss: 2.4672
Iteration: 3917; Percent complete: 97.9%; Average loss: 2.7846
Iteration: 3918; Percent complete: 98.0%; Average loss: 2.3270
Iteration: 3919; Percent complete: 98.0%; Average loss: 2.5301
Iteration: 3920; Percent complete: 98.0%; Average loss: 2.6969
Iteration: 3921; Percent complete: 98.0%; Average loss: 2.6856
Iteration: 3922; Percent complete: 98.0%; Average loss: 2.7600
Iteration: 3923; Percent complete: 98.1%; Average loss: 2.5309
Iteration: 3924; Percent complete: 98.1%; Average loss: 2.8545
Iteration: 3925; Percent complete: 98.1%; Average loss: 2.6875
Iteration: 3926; Percent complete: 98.2%; Average loss: 2.6616
Iteration: 3927; Percent complete: 98.2%; Average loss: 2.5325
Iteration: 3928; Percent complete: 98.2%; Average loss: 2.8364
Iteration: 3929; Percent complete: 98.2%; Average loss: 2.5319
Iteration: 3930; Percent complete: 98.2%; Average loss: 2.7405
Iteration: 3931; Percent complete: 98.3%; Average loss: 2.5955
Iteration: 3932; Percent complete: 98.3%; Average loss: 2.9395
Iteration: 3933; Percent complete: 98.3%; Average loss: 2.5713
Iteration: 3934; Percent complete: 98.4%; Average loss: 2.6730
Iteration: 3935; Percent complete: 98.4%; Average loss: 2.7952
Iteration: 3936; Percent complete: 98.4%; Average loss: 2.4854
Iteration: 3937; Percent complete: 98.4%; Average loss: 2.6771
Iteration: 3938; Percent complete: 98.5%; Average loss: 2.8209
Iteration: 3939; Percent complete: 98.5%; Average loss: 2.7801
Iteration: 3940; Percent complete: 98.5%; Average loss: 2.5106
Iteration: 3941; Percent complete: 98.5%; Average loss: 2.5942
Iteration: 3942; Percent complete: 98.6%; Average loss: 2.5160
Iteration: 3943; Percent complete: 98.6%; Average loss: 2.9009
Iteration: 3944; Percent complete: 98.6%; Average loss: 2.6653
Iteration: 3945; Percent complete: 98.6%; Average loss: 2.6305
Iteration: 3946; Percent complete: 98.7%; Average loss: 2.7233
Iteration: 3947; Percent complete: 98.7%; Average loss: 2.6585
Iteration: 3948; Percent complete: 98.7%; Average loss: 2.4454
Iteration: 3949; Percent complete: 98.7%; Average loss: 2.7438
Iteration: 3950; Percent complete: 98.8%; Average loss: 2.4921
Iteration: 3951; Percent complete: 98.8%; Average loss: 2.4447
Iteration: 3952; Percent complete: 98.8%; Average loss: 2.6336
Iteration: 3953; Percent complete: 98.8%; Average loss: 2.6518
Iteration: 3954; Percent complete: 98.9%; Average loss: 2.4952
Iteration: 3955; Percent complete: 98.9%; Average loss: 2.3765
Iteration: 3956; Percent complete: 98.9%; Average loss: 2.7998
Iteration: 3957; Percent complete: 98.9%; Average loss: 2.8643
Iteration: 3958; Percent complete: 99.0%; Average loss: 2.6925
Iteration: 3959; Percent complete: 99.0%; Average loss: 2.5080
Iteration: 3960; Percent complete: 99.0%; Average loss: 2.6790
Iteration: 3961; Percent complete: 99.0%; Average loss: 2.7124
Iteration: 3962; Percent complete: 99.1%; Average loss: 2.5317
Iteration: 3963; Percent complete: 99.1%; Average loss: 2.6797
Iteration: 3964; Percent complete: 99.1%; Average loss: 2.4061
Iteration: 3965; Percent complete: 99.1%; Average loss: 2.6136
Iteration: 3966; Percent complete: 99.2%; Average loss: 2.6306
Iteration: 3967; Percent complete: 99.2%; Average loss: 2.8676
Iteration: 3968; Percent complete: 99.2%; Average loss: 2.6828
Iteration: 3969; Percent complete: 99.2%; Average loss: 2.7224
Iteration: 3970; Percent complete: 99.2%; Average loss: 2.7961
Iteration: 3971; Percent complete: 99.3%; Average loss: 2.7528
Iteration: 3972; Percent complete: 99.3%; Average loss: 2.8150
Iteration: 3973; Percent complete: 99.3%; Average loss: 2.7601
Iteration: 3974; Percent complete: 99.4%; Average loss: 2.5843
Iteration: 3975; Percent complete: 99.4%; Average loss: 2.4672
Iteration: 3976; Percent complete: 99.4%; Average loss: 2.7144
Iteration: 3977; Percent complete: 99.4%; Average loss: 2.5053
Iteration: 3978; Percent complete: 99.5%; Average loss: 2.7131
Iteration: 3979; Percent complete: 99.5%; Average loss: 2.9598
Iteration: 3980; Percent complete: 99.5%; Average loss: 2.7229
Iteration: 3981; Percent complete: 99.5%; Average loss: 2.5277
Iteration: 3982; Percent complete: 99.6%; Average loss: 2.8231
Iteration: 3983; Percent complete: 99.6%; Average loss: 2.8935
Iteration: 3984; Percent complete: 99.6%; Average loss: 2.5410
Iteration: 3985; Percent complete: 99.6%; Average loss: 2.6603
Iteration: 3986; Percent complete: 99.7%; Average loss: 2.5907
Iteration: 3987; Percent complete: 99.7%; Average loss: 2.5618
Iteration: 3988; Percent complete: 99.7%; Average loss: 2.6095
Iteration: 3989; Percent complete: 99.7%; Average loss: 2.8773
Iteration: 3990; Percent complete: 99.8%; Average loss: 2.6526
Iteration: 3991; Percent complete: 99.8%; Average loss: 2.5201
Iteration: 3992; Percent complete: 99.8%; Average loss: 2.6412
Iteration: 3993; Percent complete: 99.8%; Average loss: 2.7836
Iteration: 3994; Percent complete: 99.9%; Average loss: 2.6808
Iteration: 3995; Percent complete: 99.9%; Average loss: 2.5454
Iteration: 3996; Percent complete: 99.9%; Average loss: 2.4912
Iteration: 3997; Percent complete: 99.9%; Average loss: 2.6047
Iteration: 3998; Percent complete: 100.0%; Average loss: 2.3063
Iteration: 3999; Percent complete: 100.0%; Average loss: 2.8051
Iteration: 4000; Percent complete: 100.0%; Average loss: 2.7331

运行评估#

要与您的模型聊天，请运行以下代码块。

# Set dropout layers to ``eval`` mode
encoder.eval()
decoder.eval()

# Initialize search module
searcher = GreedySearchDecoder(encoder, decoder)

# Begin chatting (uncomment and run the following line to begin)
# evaluateInput(encoder, decoder, searcher, voc)

结论#

好了，各位。恭喜您，现在您已经掌握了构建生成式聊天机器人模型的基础知识！如果您有兴趣，可以通过调整模型和训练参数以及自定义用于训练模型的数据来尝试定制聊天机器人的行为。

查看其他教程，了解 PyTorch 中更多酷炫的深度学习应用！

脚本总运行时间： (2 分 22.332 秒)

© 版权所有 2024, PyTorch。

使用 PyData Sphinx 主题 0.15.4 构建。

在此页面上
PyTorch 库