diff --git a/01_intro.ipynb b/01_intro.ipynb index d76695c..ab2d57b 100644 --- a/01_intro.ipynb +++ b/01_intro.ipynb @@ -2894,6 +2894,31 @@ "display_name": "Python 3", "language": "python", "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.7.5" + }, + "toc": { + "base_numbering": 1, + "nav_menu": {}, + "number_sections": false, + "sideBar": true, + "skip_h1_title": true, + "title_cell": "Table of Contents", + "title_sidebar": "Contents", + "toc_cell": false, + "toc_position": {}, + "toc_section_display": true, + "toc_window_display": false } }, "nbformat": 4, diff --git a/03_ethics.ipynb b/03_ethics.ipynb index 12e8afd..9984cf8 100644 --- a/03_ethics.ipynb +++ b/03_ethics.ipynb @@ -25,7 +25,7 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "This chapter was co-authored by Dr Rachel Thomas, the co-founder of fast.ai, and founding director of the Center for Applied Data Ethics at the University of San Francisco. It largely follows a subset of the syllabus she developed for the \"Introduction to Data Ethics\" course." + "This chapter was co-authored by Dr Rachel Thomas, the co-founder of fast.ai, and founding director of the Center for Applied Data Ethics at the University of San Francisco. It largely follows a subset of the syllabus she developed for the [Introduction to Data Ethics](https://ethics.fast.ai) course." ] }, { @@ -204,14 +204,9 @@ "\n", "Okay, so hopefully we have convinced you that you ought to care. But what should you do? As data scientists, we're naturally inclined to focus on making our model better at optimizing some metric. But optimizing that metric may not actually lead to better outcomes. And even if optimizing that metric *does* help create better outcomes, it almost certainly won't be the only thing that matters. Consider the pipeline of steps that occurs between the development of a model or an algorithm by a researcher or practitioner, and the point at which this work is actually used to make some decision. This entire pipeline needs to be considered *as a whole* if we're to have a hope of getting the kinds of outcomes we want.\n", "\n", - "Normally there is a very long chain from one end to the other. This is especially true if you are a researcher where you don't even know if your research will ever get used for anything, or if you're involved in data collection, which is even earlier in the pipeline. But no-one is better placed to " - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "Data often ends up being used for different purposes than why it was originally collected. IBM began selling to Nazi Germany well before the Holocaust, including helping with Germany’s 1933 census conducted by Adolf Hitler, which was effective at identifying far more Jewish people than had previously been recognized in Germany. US census data was used to round up Japanese-Americans (who were US citizens) for internment during World War II. It is important to recognize how data and images collected can be weaponized later. Columbia professor [Tim Wu wrote](https://www.nytimes.com/2019/04/10/opinion/sunday/privacy-capitalism.html) that “You must assume that any personal data that Facebook or Android keeps are data that governments around the world will try to get or that thieves will try to steal.”" + "Normally there is a very long chain from one end to the other. This is especially true if you are a researcher where you don't even know if your research will ever get used for anything, or if you're involved in data collection, which is even earlier in the pipeline. But no-one is better placed to inform everyone involved in this chain about the capabilities, constraints, and details of your work than you are. Although there's no \"silver bullet\" that can ensure your work is used the right way, by getting involved in the process, and asking the right questions, you can at the very least ensured that the right issues are being considered.\n", + "\n", + "Sometimes, the right response to being asked to do a piece of work is to just say \"no\". Often, however, the response we hear is \"if I don’t do it, someone else will\". But consider this: if you’ve been picked for the job, you’re the best person they’ve found; so if you don’t do it, the best person isn’t working on that project. If the first 5 they ask all say no too, then even better!" ] }, { @@ -391,7 +386,7 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "\"A" + "\"A" ] }, { @@ -543,7 +538,7 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "In the paper [Does Machine Learning Automate Moral Hazard and Error](https://scholar.harvard.edu/files/sendhil/files/aer.p20171084.pdf) in *American Economic Review*, the authors look at a model that tries to answer the question: using historical EHR data, what factors are most predictive of stroke? These are the top predictors from the model:\n", + "In the paper [Does Machine Learning Automate Moral Hazard and Error](https://scholar.harvard.edu/files/sendhil/files/aer.p20171084.pdf) in *American Economic Review*, the authors look at a model that tries to answer the question: using historical electronic health record (EHR) data, what factors are most predictive of stroke? These are the top predictors from the model:\n", "\n", " - Prior Stroke\n", " - Cardiovascular disease\n", @@ -703,13 +698,8 @@ "- analyze a project you are working on\n", "- implement processes at your company to find and address ethical risks\n", "- support good policy\n", - "- increase diversity" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ + "- increase diversity\n", + "\n", "Let's walk through each step next, staring with analyzing a project you are working on." ] }, @@ -732,14 +722,11 @@ " - What are error rates for different sub-groups?\n", " - What is the accuracy of a simple rule-based alternative?\n", " - What processes are in place to handle appeals or mistakes?\n", - " - How diverse is the team that built it?" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "These questions may be able to help you identify outstanding issues, and possible alternatives that are easier to understand and control. In addition to asking the right questions, it's also important to consider practices and processes to implement." + " - How diverse is the team that built it?\n", + "\n", + "These questions may be able to help you identify outstanding issues, and possible alternatives that are easier to understand and control. In addition to asking the right questions, it's also important to consider practices and processes to implement.\n", + "\n", + "One thing to consider at this stage is what data you are collecting and storing. Data often ends up being used for different purposes than why it was originally collected. For instance, IBM began selling to Nazi Germany well before the Holocaust, including helping with Germany’s 1933 census conducted by Adolf Hitler, which was effective at identifying far more Jewish people than had previously been recognized in Germany. US census data was used to round up Japanese-Americans (who were US citizens) for internment during World War II. It is important to recognize how data and images collected can be weaponized later. Columbia professor [Tim Wu wrote](https://www.nytimes.com/2019/04/10/opinion/sunday/privacy-capitalism.html) that “You must assume that any personal data that Facebook or Android keeps are data that governments around the world will try to get or that thieves will try to steal.”" ] }, { @@ -882,33 +869,71 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "### Role of Policy" + "## Role of Policy" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ - "The ethical issues that arise in the use of automated decision systems, such as machine learning, can be complex and far-reaching. To better address them, we will need thoughtful policy, in addition to the ethical efforts of those in industry. Neither is sufficient on its own.\n", - "\n", - "Policy is the appropriate tool for addressing:\n", - "\n", - "- Negative externalities\n", - "- Misaligned economic incentives\n", - "- “Race to the bottom” situations\n", - "- Enforcing accountability.\n", - "\n", - "Ethical behavior in industry is necessary as well, since:\n", - "\n", - "- Law will not always keep up\n", - "- Edge cases will arise in which practitioners must use their best judgement." + "We often talk to people who are eager for technical or design fixes to be full solution to the kinds of problems that we've been discussing; for instance, a technical approach to debias data, or design guidelines for making technology less addictive. While such measures can be useful, they will not be sufficient to address the underlying problems that have led to our current state. For example, as long as it is incredibly profitable to create addictive technology, companies will continue to do so, regardless of whether this has the side effect of promoting conspiracy theories and polluting our information ecosystem. While individual designers may try to tweak product designs, we will not see substantial changes until the underlying profit incentives changes." ] }, { "cell_type": "markdown", "metadata": {}, "source": [ - "### Conclusion" + "### The effectiveness of regulation" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "To look at what can cause companies to take concrete action, consider the following two examples of how Facebook has behaved. In 2018, a UN investigation found that Facebook had played a “determining role” in the ongoing genocide of the Rohingya, an ethnic minority in Mynamar that was described by UN Secretary-General Antonio Guterres as \"one of, if not the, most discriminated people in the world\". Local activists had been warning Facebook executives that their platform was being used to spread hate speech and incite violence since as early as 2013. In 2015, they were warned that Facebook could play the same role in Myanmar that the radio broadcasts played during the Rwandan genocide (where a million people were killed). Yet, by the end of 2015, Facebook only employed 4 contractors that spoke Burmese. As one person close to the matter said, \"That’s not 20/20 hindsight. The scale of this problem was significant and it was already apparent.\" Zuckerberg promised during the congressional hearings to hire \"dozens\" to address the genocide in Myanmar (in 2018, years after the genocide had begun, including the destruction by fire of at least 288 villages in northern Rakhine state after August 2017).\n", + "\n", + "This stands in stark contrast to Facebook quickly [hiring 1,200 people in Germany](http://thehill.com/policy/technology/361722-facebook-opens-second-german-office-to-comply-with-hate-speech-law) to try to avoid expensive penalties (of up to 50 million euros) under a new German law against hate speech. Clearly, in this case, Facebook was more reactive to the threat of a financial penalty than to the systematic destruction of an ethnic minority.\n", + "\n", + "In an [article on privacy issues](https://idlewords.com/2019/06/the_new_wilderness.htm), Maciej Ceglowski draws parallels with the environmental movement… \"This regulatory project has been so successful in the First World that we risk forgetting what life was like before it. Choking smog of the kind that today kills thousands in Jakarta and Delhi was [once emblematic of London](https://en.wikipedia.org/wiki/Pea_soup_fog). The Cuyahoga River in Ohio used to [reliably catch fire](http://www.ohiohistorycentral.org/w/Cuyahoga_River_Fire). In a particularly horrific example of unforeseen consequences, tetraethyl lead added to gasoline [raised violent crime rates](https://en.wikipedia.org/wiki/Lead%E2%80%93crime_hypothesis) worldwide for fifty years. None of these harms could have been fixed by telling people to vote with their wallet, or carefully review the environmental policies of every company they gave their business to, or to stop using the technologies in question. It took coordinated, and sometimes highly technical, regulation across jurisdictional boundaries to fix them. In some cases, like the [ban on commercial refrigerants](https://en.wikipedia.org/wiki/Montreal_Protocol) that depleted the ozone layer, that regulation required a worldwide consensus. We’re at the point where we need a similar shift in perspective in our privacy law.\"" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Rights and policy" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Clean air and clean drinking water are public goods which are nearly impossible to protect through individual market decisions, but rather require coordinated regulatory action. Similarly, many of the harms resulting from unintended consequences of misuses of technology involve public goods, such as a polluted information environment or deteriorated ambient privacy. Too often privacy is framed as an individual right, yet there are societal impacts to widespread surveillance (which would still be the case even if it was possible for a few individuals to opt out)\n", + "\n", + "Many of the issues we are seeing in tech are actually human rights issues, such as when a biased algorithm recommends that Black defendants to have longer prison sentences, when particular job ads are only shown to young people, or when police use facial recognition to identify protesters. The appropriate venue to address human rights issues is typically through the law.\n", + "\n", + "We need both regulatory and legal changes, *and* the ethical behavior of individuals. Individual behavior change can’t address misaligned profit incentives, externalities (where corporations reap large profits while off-loading their costs & harms to the broader society), or systemic failures. However, the law will never cover all edge cases, and it is important that individual software developers and data scientists are equipped to make ethical decisions in practice." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Cars: a historical precedent" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "The problems we are facing are complex and there are no simple solutions. This can be discouraging, but we find hope in considering other large challenges that people have tackled throughout history. One example is the movement to increase car safety, covered as a case study in [Datasheets for Datasets](https://arxiv.org/abs/1803.09010) and in the design podcast [99% Invisible](https://99percentinvisible.org/episode/nut-behind-wheel/). Early cars had no seatbelts, metal knobs on the dashboard that could lodge in people’s skulls during a crash, regular plate glass windows that shattered in dangerous ways, and non-collapsible steering columns that impaled drivers. However, car companies were incredibly resistant to even discussing the idea of safety as something they could help address, and the widespread belief was that cars are just the way they are, and that it was the people using them who caused problems. It took consumer safety activists and advocates decades of work to even change the national conversation to consider that perhaps car companies had some responsibility which should be addressed through regulation. When the collapsible steering column was invented, it was not implemented for several years as there was no financial incentive to do so. Major car company General Motors hired private detectives to try to dig up dirt on consumer safety advocate Ralph Nader. The requirement of seatbelts, crash test dummies, and collapsible steering columns were major victories. It was only in 2011 that car companies were required to start using crash test dummies that would represent the average women, and not just average men’s bodies; prior to this, women were 40% more likely to be injured in a car crash of the same impact compared to a man. This is a vivid example of the ways that bias, policy, and technology have important consequences." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Conclusion" ] }, { @@ -917,6 +942,8 @@ "source": [ "Coming from a background of working with binary logic, the lack of clear answers in ethics can be frustrating at first. Yet, the implications of how our work impacts the world, including unintended consequences and the work becoming weaponization by bad actors, are some of the most important questions we can (and should!) consider. Even though there aren't any easy answers, there are definite pitfalls to avoid and practices to move towards more ethical behavior.\n", "\n", + "Many people (including us!) are looking for more satisfying, solid answers of how to address harmful impacts of technology. However, given the complex, far-reaching, and interdisciplinary nature of the problems we are facing, there are no simple solutions. Julia Angwin, former senior reporter at ProPublica who focuses on issues of algorithmic bias and surveillance (and one of the 2016 investigators of the COMPAS recidivism algorithm that helped spark the field of Fairness Accountability and Transparency) said in [a 2019 interview](https://www.fastcompany.com/90337954/who-cares-about-liberty-julia-angwin-and-trevor-paglen-on-privacy-surveillance-and-the-mess-were-in), “I strongly believe that in order to solve a problem, you have to diagnose it, and that we’re still in the diagnosis phase of this. If you think about the turn of the century and industrialization, we had, I don’t know, 30 years of child labor, unlimited work hours, terrible working conditions, and it took a lot of journalist muckraking and advocacy to diagnose the problem and have some understanding of what it was, and then the activism to get laws changed. I feel like we’re in a second industrialization of data information... I see my role as trying to make as clear as possible what the downsides are, and diagnosing them really accurately so that they can be solvable. That’s hard work, and lots more people need to be doing it.” It's reassuring that Angwin thinks we are largely still in the diagnosis phase: if your understanding of these problems feels incomplete, that is normal and natural. Nobody has a “cure” yet, although it is vital that we continue working to better understand and address the problems we are facing.\n", + "\n", "One of our reviewers for this book, Fred Monroe, used to work in hedge fund trading. He told us, after reading this chapter, that many of the issues discussed here (distribution of data being dramatically different than what was trained on, impact of model and feedback loops once deployed and at scale, and so forth) were also key issues for building profitable trading models. The kinds of things you need to do to consider societal consequences are going to have a lot of overlap with things you need to do to consider organizational, market, and customer consequences too--so thinking carefully about ethics can also help you think carefully about how to make your data product successful more generally!" ] }, @@ -1029,7 +1056,10 @@ }, "toc": { "base_numbering": 1, - "nav_menu": {}, + "nav_menu": { + "height": "600px", + "width": "365px" + }, "number_sections": false, "sideBar": true, "skip_h1_title": true, diff --git a/04_mnist_basics.ipynb b/04_mnist_basics.ipynb index 4eff639..6394775 100644 --- a/04_mnist_basics.ipynb +++ b/04_mnist_basics.ipynb @@ -31,11 +31,13 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "Now that we’ve seen what it looks like to actually train a variety of models, let’s now dig under the hood and see exactly what is going on. We’ll start with computer vision, and will use that to introduce many key tools and concepts of deep learning. We'll discuss the role of arrays and tensors, and of brodcasting, a powerful technique for using them expressively. We'll explain stochastic gradient descent (SGD), the mechanism for learning by updating weights automatically. We'll discuss the choice of loss function for for such a classification task, and the role of mini-batches. And we'll put these pieces together, to see how they all fit.\n", + "Having seen what it looks like to actually train a variety of models in chapter 2, let’s now look under the hood and see exactly what is going on. We’ll start with computer vision, and will use that to introduce fundamental tools and concepts of deep learning.\n", "\n", - "In future chapters we’ll do deep dives into other applications as well, and see how these concepts and tools generalize.\n", + "To be exact, we'll discuss the role of arrays and tensors, and of brodcasting, a powerful technique for using them expressively. We'll explain stochastic gradient descent (SGD), the mechanism for learning by updating weights automatically. We'll discuss the choice of loss function for our basic classification task, and the role of mini-batches. We'll also finally describe the math that a basic neural network is actually doing. Finally, we'll put all these pieces together to see them working together.\n", "\n", - "But for now, let's start by considering how images are represented in a computer, then we will make our way up to how to classify different type of images." + "In future chapters we’ll do deep dives into other applications as well, and see how these concepts and tools generalize. But this chapter is about laying foundation stones. To be frank, that also makes this one of the harder chapters, because of how these concepts all depend on each other. Like an arch, all the stones need to be in place for the structure to stay up. Also like an arch, once that happens, it's a powerful structure that can support other things. But it requires some patience to assemble.\n", + "\n", + "So let us begin. The first step is to consider how images are represented in a computer." ] }, { @@ -122,7 +124,7 @@ { "data": { "text/plain": [ - "(#9) [Path('cleaned.csv'),Path('item_list.txt'),Path('trained_model.pkl'),Path('models'),Path('valid'),Path('labels.csv'),Path('export.pkl'),Path('history.csv'),Path('train')]" + "(#3) [Path('valid'),Path('train'),Path('labels.csv')]" ] }, "execution_count": null, @@ -149,7 +151,7 @@ { "data": { "text/plain": [ - "(#2) [Path('train/7'),Path('train/3')]" + "(#2) [Path('train/3'),Path('train/7')]" ] }, "execution_count": null, @@ -206,7 +208,7 @@ "data": { "image/png": "iVBORw0KGgoAAAANSUhEUgAAABwAAAAcCAAAAABXZoBIAAAA9ElEQVR4nM3Or0sDcRjH8c/pgrfBVBjCgibThiKIyTWbWF1bORhGwxARxH/AbtW0JoIGwzXRYhJhtuFY2q1ocLgbe3sGReTuuWbwkx6+r+/zQ/pncX6q+YOldSe6nG3dn8U/rTQ70L8FCGJUewvxl7NTmezNb8xIkvKugr1HSeMP6SrWOVkoTEuSyh0Gm2n3hQyObMnXnxkempRrvgD+gokzwxFAr7U7YXHZ8x4A/Dl7rbu6D2yl3etcw/F3nZgfRVI7rXM7hMUUqzzBec427x26rkmlkzEEa4nnRqnSOH2F0UUx0ePzlbuqMXAHgN6GY9if5xP8dmtHFfwjuQAAAABJRU5ErkJggg==\n", "text/plain": [ - "" + "" ] }, "execution_count": null, @@ -302,1034 +304,1034 @@ "data": { "text/html": [ "\n", + " }
0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17
\n", " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", " \n", " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", " \n", " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", " \n", " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", " \n", " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", " \n", " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", " \n", " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", " \n", " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", " \n", " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", " \n", " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", " \n", " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", " \n", "
0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17
00000000000000000000000000000000000000
10000029150195254255254176193150960001000002915019525425525417619315096000
200048166224253253234196253253253253233000200048166224253253234196253253253253233000
309324424925318746108410194253253233000309324424925318746108410194253253233000
401072532532304800000192253253156000401072532532304800000192253253156000
503202015000004322425324574000503202015000004322425324574000
600000000002492532451260000600000000002492532451260000
700000001410122325324812400000700000001410122325324812400000
800000111662392532532531873000000800000111662392532532531873000000
9000001624825025325325325323221311120090000016248250253253253253232213111200
100000000439898208253253253253187220100000000439898208253253253253187220
" ], "text/plain": [ - "" + "" ] }, "execution_count": null, @@ -1437,7 +1439,7 @@ "outputs": [ { "data": { - "image/png": "iVBORw0KGgoAAAANSUhEUgAAAEQAAABECAYAAAA4E5OyAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADh0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uMy4xLjEsIGh0dHA6Ly9tYXRwbG90bGliLm9yZy8QZhcZAAADjElEQVR4nO2aPyh9YRjHP/f4k38L5X+ysohsUpTBhEVMJGUyGAwWg0kGkcFqlMFIyv+kSGIwKWUiUvKn5P/9DXrvcR+He+695957+vV8llPnvvd9n77n2/s8z3tOIBgMothYqQ7Ab6ggAhVEoIIIVBBBeoTf/+cUFHC6qQ4RqCACFUSggghUEIEKIlBBBCqIQAURRKpUPeHh4QGAyclJAI6PjwFYXl4GIBgMEgh8FY59fX0A3N7eAlBTUwNAU1MTAC0tLQmNVR0iCEQ4MYupl7m4uABgYmICgJWVFQDOz8/DxhUVFQFQX18fGvMbxcXFAFxeXsYSkhPay7jBkz1ke3sbgLa2NgBeX18BeH9/B6CzsxOAnZ0dAAoLCwFC+4ZlWXx8fISNXVpa8iK0qFGHCDxxyN3dHQBPT09h98vLywGYmpoCoKys7Nc5LMsKu0p6enrijtMN6hCBJ1nm8/MTgOfn57D75mlnZWVFnOPq6gqAxsZGwM5I2dnZAOzu7gJQW1vrJiQ3aJZxgyd7iHFCTk5OzHNUVlYCdmYyzjDVrYfO+BN1iCApvYzk5eUFgM3NTQCGhoZCzsjMzARgenoagIGBgaTGpg4RJMUhpnIdHh4GYH5+HrDrl++0t7cD0NXVlYzQfqAOESSk25WY+iQ/Px8g1LeYqxMlJSUAlJaWAjAyMgLYvY7pg+LAcYKkCCIxRdjJyUno3tjYGAD7+/t//tcIMjc3B0Bubm6sYWhh5oaUOMSJt7c3wHaPScn9/f2O4w8PDwGoq6uLdUl1iBtSUpg5kZGRAUBFRQUAvb29AKyurgKwsLAQNn5tbQ2IyyGOqEMEvnGIxKTV39JrdXV1QtZVhwh8k2Uke3t7ADQ3NwP2sYDh5uYGgIKCgliX0CzjBt/tIWdnZwAMDg4CP51h6pK8vLyErK8OEfhmDzF1RUdHB2AfIhnMEePp6Slg1y1xoHuIG1K6h1xfXwMwOzvL+Pg48PVpxHfMS+6trS3AE2f8iTpE4KlDzBPf2NgA7I9bHh8fATg4OADg6OgIsM807u/vQ3OkpaUB9qvLmZkZIHFZRaIOEXiaZbq7uwFYXFyMOpDW1lYARkdHAWhoaIh6jijRLOMGTx1iPnIxtUQkzEHy+vo6VVVVXwHFf3jsFnWIG3xTqaYAdYgbVBCBCiJQQQQqiCBSL5O0osAvqEMEKohABRGoIAIVRKCCCP4B/PMI7HrW9/wAAAAASUVORK5CYII=\n", + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAEQAAABECAYAAAA4E5OyAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADh0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uMy4xLjMsIGh0dHA6Ly9tYXRwbG90bGliLm9yZy+AADFEAAADjElEQVR4nO2aPyh9YRjHP/f4k38L5X+ysohsUpTBhEVMJGUyGAwWg0kGkcFqlMFIyv+kSGIwKWUiUvKn5P/9DXrvcR+He+695957+vV8llPnvvd9n77n2/s8z3tOIBgMothYqQ7Ab6ggAhVEoIIIVBBBeoTf/+cUFHC6qQ4RqCACFUSggghUEIEKIlBBBCqIQAURRKpUPeHh4QGAyclJAI6PjwFYXl4GIBgMEgh8FY59fX0A3N7eAlBTUwNAU1MTAC0tLQmNVR0iCEQ4MYupl7m4uABgYmICgJWVFQDOz8/DxhUVFQFQX18fGvMbxcXFAFxeXsYSkhPay7jBkz1ke3sbgLa2NgBeX18BeH9/B6CzsxOAnZ0dAAoLCwFC+4ZlWXx8fISNXVpa8iK0qFGHCDxxyN3dHQBPT09h98vLywGYmpoCoKys7Nc5LMsKu0p6enrijtMN6hCBJ1nm8/MTgOfn57D75mlnZWVFnOPq6gqAxsZGwM5I2dnZAOzu7gJQW1vrJiQ3aJZxgyd7iHFCTk5OzHNUVlYCdmYyzjDVrYfO+BN1iCApvYzk5eUFgM3NTQCGhoZCzsjMzARgenoagIGBgaTGpg4RJMUhpnIdHh4GYH5+HrDrl++0t7cD0NXVlYzQfqAOESSk25WY+iQ/Px8g1LeYqxMlJSUAlJaWAjAyMgLYvY7pg+LAcYKkCCIxRdjJyUno3tjYGAD7+/t//tcIMjc3B0Bubm6sYWhh5oaUOMSJt7c3wHaPScn9/f2O4w8PDwGoq6uLdUl1iBtSUpg5kZGRAUBFRQUAvb29AKyurgKwsLAQNn5tbQ2IyyGOqEMEvnGIxKTV39JrdXV1QtZVhwh8k2Uke3t7ADQ3NwP2sYDh5uYGgIKCgliX0CzjBt/tIWdnZwAMDg4CP51h6pK8vLyErK8OEfhmDzF1RUdHB2AfIhnMEePp6Slg1y1xoHuIG1K6h1xfXwMwOzvL+Pg48PVpxHfMS+6trS3AE2f8iTpE4KlDzBPf2NgA7I9bHh8fATg4OADg6OgIsM807u/vQ3OkpaUB9qvLmZkZIHFZRaIOEXiaZbq7uwFYXFyMOpDW1lYARkdHAWhoaIh6jijRLOMGTx1iPnIxtUQkzEHy+vo6VVVVXwHFf3jsFnWIG3xTqaYAdYgbVBCBCiJQQQQqiCBSL5O0osAvqEMEKohABRGoIAIVRKCCCP4B/PMI7HrW9/wAAAAASUVORK5CYII=\n", "text/plain": [ "
" ] @@ -1564,7 +1566,7 @@ "outputs": [ { "data": { - "image/png": "iVBORw0KGgoAAAANSUhEUgAAAEQAAABECAYAAAA4E5OyAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADh0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uMy4xLjEsIGh0dHA6Ly9tYXRwbG90bGliLm9yZy8QZhcZAAAE1klEQVR4nO2byU8jPRTEf2En7AgQO4gDi9hO8P9fOIE4AGIR+xoU1kAgQAKZA6o4eUMU6O7R983IdbE66XYHv3K98rOJ5fN5PByq/usf8H+DHxADPyAGfkAM/IAY1FT4/l9OQbGvPvQMMfADYuAHxMAPiIEfEINKWSYSaL1kW/t9MWKx2JfX5T6PCp4hBpEwxEb+/f0dgFwuB0A2mwXg6emppH1+fgbg9fWVj48PAGprawGIx+MANDc3A9DU1ARAfX19yX3V1dVAeQb9FJ4hBqEYIkZYJmQyGQBub28BuLi4AGBnZweAvb09AM7PzwFIJpOFPsSEvr4+AMbHxwGYnZ0FYHR0FICuri7AMUiMqar6jHFQpniGGARiSDmtkDZcXV0BsL+/D8Da2hoAu7u7ABwcHACOOalUipeXl5J3tLW1AXB6elrS58LCAgBTU1MA9Pf3A44pYkhQeIYYhGKIMoMYoigXZw+AmprP13R2dgJuvo+NjQGf2qNnbm5uSvp4e3sD4O7uDnC6I41Rn8pK+m1eQyJCJFlG0VDkW1tbARgaGgKgo6MDcFEX5CFyuVwhIx0dHQFwcnICOF3SO8RGsbOc+w0KzxCDUAyRoivSmse6lvIrGymqgqKayWRIJBIAXF9fl/Ste6RD8il6V11dXcn93qlGjEAMURQUFUVP19ISO8/FFGWfx8dH4NNjbGxsALC1tQU4DWloaAAc2wYGBgCXXRobGwHHyrDwDDGIREMsY8QMtVrjKMtcXl4CsLm5CcDq6irr6+uAc7fqc35+HoDe3l7AOVNlsqjWMIW/KdTT/yBCaUglVyjNSKVSgIv+0tISACsrKwAsLy8XHKhYJScqBrS0tABOU6JmhuAZYhBKQyxTBF0rm2ilKp3Q6lcMSSQSBWbIX6gyJv2RPxHburu7S+6zlbOgiLTIbBd9tjygHytBnJ6eBmBkZKTQh50KelZlABWZ2tvbATeFoiol+iljEMnizk4Zu9iTiVIZUNcyZvl8vsAmlR+TySRAwdI/PDwAcHh4CMDw8DDgmGItfFCj5hliEKpAZDWjXDnAFnGkGcXPSyskmipEizlKy/peDBJTrFELWijyDDH4EUMsI2xrmaPoKDVqnlsUM0T3SDO03NcC0pYrldpticFrSEQIpCG2uKxWURLEEEVLGcBuFcRisd88ixiirKN32ixiWesXdxEjlIbYTWw7nxUt6YLdqC4uHIsRcqTb29uA8yF6l5yptEV9e6f6hxDKh2i+q/CjzSQ5UGUCRdEu3IR0Os3x8THgmCEfoj61ua1FXU9PD+BKi9apBoVniMGPGGLnp90qSKfTgCsEyV1KY3SfXcmmUqlCiUDPaAtzcHAQcI50cnIScAUkOVT5FJ9lIkYgDZGiKyrSBm0JCPf394DTA2UQfS6NyWazBdboGMTMzAwAc3NzACwuLgIwMTEBOA0pVw8JCs8Qg0AaomhK2VUA1haBXcvY+8/OzgDnQuPxeEEjdERCtZNymmFLh2Gzi+AZYhCrcIzgyy8rHcOUY1V2kQtVK99SfBRTkbetdMkew4xg+8H/e8h3EIghZW8uc4S70tFu+N3jVGojgGfIdxApQ/4yeIZ8B35ADPyAGFRyqtH+d85fAM8QAz8gBn5ADPyAGPgBMfADYvALMumtb+Vr5kIAAAAASUVORK5CYII=\n", + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAEQAAABECAYAAAA4E5OyAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADh0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uMy4xLjMsIGh0dHA6Ly9tYXRwbG90bGliLm9yZy+AADFEAAAE1klEQVR4nO2byU8jPRTEf2En7AgQO4gDi9hO8P9fOIE4AGIR+xoU1kAgQAKZA6o4eUMU6O7R983IdbE66XYHv3K98rOJ5fN5PByq/usf8H+DHxADPyAGfkAM/IAY1FT4/l9OQbGvPvQMMfADYuAHxMAPiIEfEINKWSYSaL1kW/t9MWKx2JfX5T6PCp4hBpEwxEb+/f0dgFwuB0A2mwXg6emppH1+fgbg9fWVj48PAGprawGIx+MANDc3A9DU1ARAfX19yX3V1dVAeQb9FJ4hBqEYIkZYJmQyGQBub28BuLi4AGBnZweAvb09AM7PzwFIJpOFPsSEvr4+AMbHxwGYnZ0FYHR0FICuri7AMUiMqar6jHFQpniGGARiSDmtkDZcXV0BsL+/D8Da2hoAu7u7ABwcHACOOalUipeXl5J3tLW1AXB6elrS58LCAgBTU1MA9Pf3A44pYkhQeIYYhGKIMoMYoigXZw+AmprP13R2dgJuvo+NjQGf2qNnbm5uSvp4e3sD4O7uDnC6I41Rn8pK+m1eQyJCJFlG0VDkW1tbARgaGgKgo6MDcFEX5CFyuVwhIx0dHQFwcnICOF3SO8RGsbOc+w0KzxCDUAyRoivSmse6lvIrGymqgqKayWRIJBIAXF9fl/Ste6RD8il6V11dXcn93qlGjEAMURQUFUVP19ISO8/FFGWfx8dH4NNjbGxsALC1tQU4DWloaAAc2wYGBgCXXRobGwHHyrDwDDGIREMsY8QMtVrjKMtcXl4CsLm5CcDq6irr6+uAc7fqc35+HoDe3l7AOVNlsqjWMIW/KdTT/yBCaUglVyjNSKVSgIv+0tISACsrKwAsLy8XHKhYJScqBrS0tABOU6JmhuAZYhBKQyxTBF0rm2ilKp3Q6lcMSSQSBWbIX6gyJv2RPxHburu7S+6zlbOgiLTIbBd9tjygHytBnJ6eBmBkZKTQh50KelZlABWZ2tvbATeFoiol+iljEMnizk4Zu9iTiVIZUNcyZvl8vsAmlR+TySRAwdI/PDwAcHh4CMDw8DDgmGItfFCj5hliEKpAZDWjXDnAFnGkGcXPSyskmipEizlKy/peDBJTrFELWijyDDH4EUMsI2xrmaPoKDVqnlsUM0T3SDO03NcC0pYrldpticFrSEQIpCG2uKxWURLEEEVLGcBuFcRisd88ixiirKN32ixiWesXdxEjlIbYTWw7nxUt6YLdqC4uHIsRcqTb29uA8yF6l5yptEV9e6f6hxDKh2i+q/CjzSQ5UGUCRdEu3IR0Os3x8THgmCEfoj61ua1FXU9PD+BKi9apBoVniMGPGGLnp90qSKfTgCsEyV1KY3SfXcmmUqlCiUDPaAtzcHAQcI50cnIScAUkOVT5FJ9lIkYgDZGiKyrSBm0JCPf394DTA2UQfS6NyWazBdboGMTMzAwAc3NzACwuLgIwMTEBOA0pVw8JCs8Qg0AaomhK2VUA1haBXcvY+8/OzgDnQuPxeEEjdERCtZNymmFLh2Gzi+AZYhCrcIzgyy8rHcOUY1V2kQtVK99SfBRTkbetdMkew4xg+8H/e8h3EIghZW8uc4S70tFu+N3jVGojgGfIdxApQ/4yeIZ8B35ADPyAGFRyqtH+d85fAM8QAz8gBn5ADPyAGPgBMfADYvALMumtb+Vr5kIAAAAASUVORK5CYII=\n", "text/plain": [ "
" ] @@ -1594,7 +1596,7 @@ "outputs": [ { "data": { - "image/png": "iVBORw0KGgoAAAANSUhEUgAAAEQAAABECAYAAAA4E5OyAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADh0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uMy4xLjEsIGh0dHA6Ly9tYXRwbG90bGliLm9yZy8QZhcZAAAElUlEQVR4nO2bSUszWRSGn3JKUGOM84giCA7oQnHj33ejiKCI4MIpxhES5ylx6oW8dTvnMyaWJd1033dzqVRqyLlPnelWgvf3d7yc6v7pG/i3yRvEyBvEyBvEyBvEqKHK/v9yCAo++9ATYuQNYuQNYuQNYuQNYuQNYuQNYuQNYuQNYlQtU42kaj2Wz/YHwaeJY+TvRZUnxOhHhGimNb69vZWNr6+vX25r/Ep1dR9zVl9f/3HDDQ1l29qvUQRFJckTYvQtQiwRmvGXlxcAnp6eALi9vQXg+voagMvLSwAuLi7KxoeHh/A4nUOjrtHU1ARAR0cHAENDQwAMDw8D0NvbC0BraysAjY2NgCPou6R4QowiEaJZfH5+BhwR+XwegIODAwC2t7cB2NvbA+Dw8BCAo6MjAK6urgAoFovhuUSdRhEiMubn5wFYXFwEYGFhoWx/JZ9SqzwhRpEIUXTQrN7f3wNQKBQA2N/fB2B3dxdwpIicm5ubsvMlEgkSiQTgyBB1Oufj4yPgfMXo6GjZtXWc5KNMTKqJkGqZp2ZDnr25uRmA9vZ2AEZGRgDo7u4GnF/Q/nQ6HRKiGRdNq6urgPM3IsFe0+YlUeUJMaqJEJv9aRaUNYqIzs5OAMbGxsr29/f3A44Mbff19QEffkEzrBxlaWkJgLOzM8DlOJlMpmxsa2sDXP4RNbpInhCjb0WZaoTYGkVEaDuVSgGOJM1uQ0NDmNtYKdroXD09PYDzS+l0GnCE/LQa9oQYRap2K1WglhRFDn2/paUF+LPuCIIgPEY5irLb8/NzwNUyqmEGBgbKrql7+akiPTKSNYx+oH64DCKDCXttS6+vr2G43dzcBGB9fR1wj8zU1BTgHhWFbHsuSamCT91/qB81iKyTFSkiwTo6jXo8NIulUolsNgvA8vIyADs7O4CjTKFcox6VuFuKnhCjSIRU8iX2ubUNJdtYUnGYz+dZWVkBYG1tDXCJ2OzsLACTk5OAC7vJZLLs2nGR4gkximUZwhZalZrOkvarpM/lcmxsbAAuzKoQVENoZmYGcOFXfsq2Cn1iFrNiiTJ22/oSjXYZQknY1tYWuVwOcDM/NzcHOB8yODgIuKRO+YdtGVa6t1rlCTGK1YdUyg7tfvmO09NTALLZbLgkoTxjenoagImJCcBlprbMj4sMyRNiFOtityVBks8olUqAawIpGy0UCiEBKt7Gx8cB6OrqAqrnHT4P+SXFSkiljFRkaGnz5OQEcO3BIAjCdqKWF7TwpMrZRpXfei3CE2IUCyGVXouwC1la6jw+PgZcvZJKpcJ2oho/2lZe8tPlhVrlCTH6FR+ihrF8h7peWmy6u7sDXE6RyWTCaKJqVv0O+Y64apVq8oQY/corVYou8hHKTLUtMuQnEolE+OLL3z+D6C++RJUnxCiWarfaYriI0EKVljIVhZLJZLjgpIxVmWmlrvpvyRNiFFSZ3Zr+YmZ9iH3lStFGPqRYLJYdFwRBSJHIkA+xL9HF2CHzfzGrRbEQ8sdBFc5po9JX37cE/EIe4gmpRdUI+d/JE2LkDWLkDWLkDWLkDWLkDWL0F7hnDWZImx+vAAAAAElFTkSuQmCC\n", + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAEQAAABECAYAAAA4E5OyAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADh0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uMy4xLjMsIGh0dHA6Ly9tYXRwbG90bGliLm9yZy+AADFEAAAElUlEQVR4nO2bSUszWRSGn3JKUGOM84giCA7oQnHj33ejiKCI4MIpxhES5ylx6oW8dTvnMyaWJd1033dzqVRqyLlPnelWgvf3d7yc6v7pG/i3yRvEyBvEyBvEyBvEqKHK/v9yCAo++9ATYuQNYuQNYuQNYuQNYuQNYuQNYuQNYuQNYlQtU42kaj2Wz/YHwaeJY+TvRZUnxOhHhGimNb69vZWNr6+vX25r/Ep1dR9zVl9f/3HDDQ1l29qvUQRFJckTYvQtQiwRmvGXlxcAnp6eALi9vQXg+voagMvLSwAuLi7KxoeHh/A4nUOjrtHU1ARAR0cHAENDQwAMDw8D0NvbC0BraysAjY2NgCPou6R4QowiEaJZfH5+BhwR+XwegIODAwC2t7cB2NvbA+Dw8BCAo6MjAK6urgAoFovhuUSdRhEiMubn5wFYXFwEYGFhoWx/JZ9SqzwhRpEIUXTQrN7f3wNQKBQA2N/fB2B3dxdwpIicm5ubsvMlEgkSiQTgyBB1Oufj4yPgfMXo6GjZtXWc5KNMTKqJkGqZp2ZDnr25uRmA9vZ2AEZGRgDo7u4GnF/Q/nQ6HRKiGRdNq6urgPM3IsFe0+YlUeUJMaqJEJv9aRaUNYqIzs5OAMbGxsr29/f3A44Mbff19QEffkEzrBxlaWkJgLOzM8DlOJlMpmxsa2sDXP4RNbpInhCjb0WZaoTYGkVEaDuVSgGOJM1uQ0NDmNtYKdroXD09PYDzS+l0GnCE/LQa9oQYRap2K1WglhRFDn2/paUF+LPuCIIgPEY5irLb8/NzwNUyqmEGBgbKrql7+akiPTKSNYx+oH64DCKDCXttS6+vr2G43dzcBGB9fR1wj8zU1BTgHhWFbHsuSamCT91/qB81iKyTFSkiwTo6jXo8NIulUolsNgvA8vIyADs7O4CjTKFcox6VuFuKnhCjSIRU8iX2ubUNJdtYUnGYz+dZWVkBYG1tDXCJ2OzsLACTk5OAC7vJZLLs2nGR4gkximUZwhZalZrOkvarpM/lcmxsbAAuzKoQVENoZmYGcOFXfsq2Cn1iFrNiiTJ22/oSjXYZQknY1tYWuVwOcDM/NzcHOB8yODgIuKRO+YdtGVa6t1rlCTGK1YdUyg7tfvmO09NTALLZbLgkoTxjenoagImJCcBlprbMj4sMyRNiFOtityVBks8olUqAawIpGy0UCiEBKt7Gx8cB6OrqAqrnHT4P+SXFSkiljFRkaGnz5OQEcO3BIAjCdqKWF7TwpMrZRpXfei3CE2IUCyGVXouwC1la6jw+PgZcvZJKpcJ2oho/2lZe8tPlhVrlCTH6FR+ihrF8h7peWmy6u7sDXE6RyWTCaKJqVv0O+Y64apVq8oQY/corVYou8hHKTLUtMuQnEolE+OLL3z+D6C++RJUnxCiWarfaYriI0EKVljIVhZLJZLjgpIxVmWmlrvpvyRNiFFSZ3Zr+YmZ9iH3lStFGPqRYLJYdFwRBSJHIkA+xL9HF2CHzfzGrRbEQ8sdBFc5po9JX37cE/EIe4gmpRdUI+d/JE2LkDWLkDWLkDWLkDWLkDWL0F7hnDWZImx+vAAAAAElFTkSuQmCC\n", "text/plain": [ "
" ] @@ -1628,7 +1630,7 @@ "outputs": [ { "data": { - "image/png": "iVBORw0KGgoAAAANSUhEUgAAAEQAAABECAYAAAA4E5OyAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADh0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uMy4xLjEsIGh0dHA6Ly9tYXRwbG90bGliLm9yZy8QZhcZAAADjElEQVR4nO2aPyh9YRjHP/f4k38L5X+ysohsUpTBhEVMJGUyGAwWg0kGkcFqlMFIyv+kSGIwKWUiUvKn5P/9DXrvcR+He+695957+vV8llPnvvd9n77n2/s8z3tOIBgMothYqQ7Ab6ggAhVEoIIIVBBBeoTf/+cUFHC6qQ4RqCACFUSggghUEIEKIlBBBCqIQAURRKpUPeHh4QGAyclJAI6PjwFYXl4GIBgMEgh8FY59fX0A3N7eAlBTUwNAU1MTAC0tLQmNVR0iCEQ4MYupl7m4uABgYmICgJWVFQDOz8/DxhUVFQFQX18fGvMbxcXFAFxeXsYSkhPay7jBkz1ke3sbgLa2NgBeX18BeH9/B6CzsxOAnZ0dAAoLCwFC+4ZlWXx8fISNXVpa8iK0qFGHCDxxyN3dHQBPT09h98vLywGYmpoCoKys7Nc5LMsKu0p6enrijtMN6hCBJ1nm8/MTgOfn57D75mlnZWVFnOPq6gqAxsZGwM5I2dnZAOzu7gJQW1vrJiQ3aJZxgyd7iHFCTk5OzHNUVlYCdmYyzjDVrYfO+BN1iCApvYzk5eUFgM3NTQCGhoZCzsjMzARgenoagIGBgaTGpg4RJMUhpnIdHh4GYH5+HrDrl++0t7cD0NXVlYzQfqAOESSk25WY+iQ/Px8g1LeYqxMlJSUAlJaWAjAyMgLYvY7pg+LAcYKkCCIxRdjJyUno3tjYGAD7+/t//tcIMjc3B0Bubm6sYWhh5oaUOMSJt7c3wHaPScn9/f2O4w8PDwGoq6uLdUl1iBtSUpg5kZGRAUBFRQUAvb29AKyurgKwsLAQNn5tbQ2IyyGOqEMEvnGIxKTV39JrdXV1QtZVhwh8k2Uke3t7ADQ3NwP2sYDh5uYGgIKCgliX0CzjBt/tIWdnZwAMDg4CP51h6pK8vLyErK8OEfhmDzF1RUdHB2AfIhnMEePp6Slg1y1xoHuIG1K6h1xfXwMwOzvL+Pg48PVpxHfMS+6trS3AE2f8iTpE4KlDzBPf2NgA7I9bHh8fATg4OADg6OgIsM807u/vQ3OkpaUB9qvLmZkZIHFZRaIOEXiaZbq7uwFYXFyMOpDW1lYARkdHAWhoaIh6jijRLOMGTx1iPnIxtUQkzEHy+vo6VVVVXwHFf3jsFnWIG3xTqaYAdYgbVBCBCiJQQQQqiCBSL5O0osAvqEMEKohABRGoIAIVRKCCCP4B/PMI7HrW9/wAAAAASUVORK5CYII=\n", + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAEQAAABECAYAAAA4E5OyAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADh0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uMy4xLjMsIGh0dHA6Ly9tYXRwbG90bGliLm9yZy+AADFEAAADjElEQVR4nO2aPyh9YRjHP/f4k38L5X+ysohsUpTBhEVMJGUyGAwWg0kGkcFqlMFIyv+kSGIwKWUiUvKn5P/9DXrvcR+He+695957+vV8llPnvvd9n77n2/s8z3tOIBgMothYqQ7Ab6ggAhVEoIIIVBBBeoTf/+cUFHC6qQ4RqCACFUSggghUEIEKIlBBBCqIQAURRKpUPeHh4QGAyclJAI6PjwFYXl4GIBgMEgh8FY59fX0A3N7eAlBTUwNAU1MTAC0tLQmNVR0iCEQ4MYupl7m4uABgYmICgJWVFQDOz8/DxhUVFQFQX18fGvMbxcXFAFxeXsYSkhPay7jBkz1ke3sbgLa2NgBeX18BeH9/B6CzsxOAnZ0dAAoLCwFC+4ZlWXx8fISNXVpa8iK0qFGHCDxxyN3dHQBPT09h98vLywGYmpoCoKys7Nc5LMsKu0p6enrijtMN6hCBJ1nm8/MTgOfn57D75mlnZWVFnOPq6gqAxsZGwM5I2dnZAOzu7gJQW1vrJiQ3aJZxgyd7iHFCTk5OzHNUVlYCdmYyzjDVrYfO+BN1iCApvYzk5eUFgM3NTQCGhoZCzsjMzARgenoagIGBgaTGpg4RJMUhpnIdHh4GYH5+HrDrl++0t7cD0NXVlYzQfqAOESSk25WY+iQ/Px8g1LeYqxMlJSUAlJaWAjAyMgLYvY7pg+LAcYKkCCIxRdjJyUno3tjYGAD7+/t//tcIMjc3B0Bubm6sYWhh5oaUOMSJt7c3wHaPScn9/f2O4w8PDwGoq6uLdUl1iBtSUpg5kZGRAUBFRQUAvb29AKyurgKwsLAQNn5tbQ2IyyGOqEMEvnGIxKTV39JrdXV1QtZVhwh8k2Uke3t7ADQ3NwP2sYDh5uYGgIKCgliX0CzjBt/tIWdnZwAMDg4CP51h6pK8vLyErK8OEfhmDzF1RUdHB2AfIhnMEePp6Slg1y1xoHuIG1K6h1xfXwMwOzvL+Pg48PVpxHfMS+6trS3AE2f8iTpE4KlDzBPf2NgA7I9bHh8fATg4OADg6OgIsM807u/vQ3OkpaUB9qvLmZkZIHFZRaIOEXiaZbq7uwFYXFyMOpDW1lYARkdHAWhoaIh6jijRLOMGTx1iPnIxtUQkzEHy+vo6VVVVXwHFf3jsFnWIG3xTqaYAdYgbVBCBCiJQQQQqiCBSL5O0osAvqEMEKohABRGoIAIVRKCCCP4B/PMI7HrW9/wAAAAASUVORK5CYII=\n", "text/plain": [ "
" ] @@ -2121,7 +2123,7 @@ { "data": { "text/plain": [ - "(tensor([0.1050, 0.1526, 0.1186, ..., 0.1122, 0.1170, 0.1086]),\n", + "(tensor([0.1156, 0.1257, 0.1369, ..., 0.1493, 0.1366, 0.1107]),\n", " torch.Size([1010]))" ] }, @@ -2378,11 +2380,11 @@ "\n", "\n", - "\n", + "\n", "\n", "G\n", - "\n", + "\n", "\n", "\n", "init\n", @@ -2392,75 +2394,75 @@ "\n", "\n", "predict\n", - "\n", - "predict\n", + "\n", + "predict\n", "\n", "\n", "\n", "init->predict\n", - "\n", - "\n", + "\n", + "\n", "\n", "\n", "\n", "loss\n", - "\n", - "loss\n", + "\n", + "loss\n", "\n", "\n", "\n", "predict->loss\n", - "\n", - "\n", + "\n", + "\n", "\n", "\n", "\n", "gradient\n", - "\n", - "gradient\n", + "\n", + "gradient\n", "\n", "\n", "\n", "loss->gradient\n", - "\n", - "\n", + "\n", + "\n", "\n", "\n", "\n", "step\n", - "\n", - "step\n", + "\n", + "step\n", "\n", "\n", "\n", "gradient->step\n", - "\n", - "\n", + "\n", + "\n", "\n", "\n", "\n", "step->predict\n", - "\n", - "\n", - "repeat\n", + "\n", + "\n", + "repeat\n", "\n", "\n", "\n", "stop\n", - "\n", - "stop\n", + "\n", + "stop\n", "\n", "\n", "\n", "step->stop\n", - "\n", - "\n", + "\n", + "\n", "\n", "\n", "\n" ], "text/plain": [ - "" + "" ] }, "execution_count": null, @@ -2522,7 +2524,7 @@ "outputs": [ { "data": { - "image/png": "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\n", + "image/png": "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\n", "text/plain": [ "
" ] @@ -2551,7 +2553,7 @@ "outputs": [ { "data": { - "image/png": "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\n", + "image/png": "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\n", "text/plain": [ "
" ] @@ -2922,7 +2924,7 @@ "outputs": [ { "data": { - "image/png": "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\n", + "image/png": "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\n", "text/plain": [ "
" ] @@ -3049,7 +3051,7 @@ "outputs": [ { "data": { - "image/png": "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\n", + "image/png": "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\n", "text/plain": [ "
" ] @@ -3231,7 +3233,7 @@ "outputs": [ { "data": { - "image/png": "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\n", + "image/png": "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\n", "text/plain": [ "
" ] @@ -3328,7 +3330,7 @@ "outputs": [ { "data": { - "image/png": "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\n", + "image/png": "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\n", "text/plain": [ "
" ] @@ -3381,9 +3383,9 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "Let's get back to our MNIST problem. As we've seen, we need gradients in order to improve our model, and in order to calculate gradients we need some *loss function* that represents how good our model is. That is because the gradients are a measure of how that loss function changes with small tweaks to the weights.\n", + "Let's get back to our MNIST problem. As we've seen, we need gradients in order to improve our model using SGD, and in order to calculate gradients we need some *loss function* that represents how good our model is. That is because the gradients are a measure of how that loss function changes with small tweaks to the weights.\n", "\n", - "The obvious approach would be to use the accuracy as our loss function. In this case, we would calculate our prediction for each image, and then calculate the overall accuracy (remember, at first we simply use random weights), and then calculate the gradients of each weight with respect to that accuracy calculation.\n", + "So we need to choose a loss function. The obvious approach would be to use accuracy, which is our metric, as our loss function as well. In this case, we would calculate our prediction for each image, collect these values to calculate an overall accuracy, and then calculate the gradients of each weight with respect to that overall accuracy.\n", "\n", "Unfortunately, we have a significant technical problem here. The gradient of a function is its *slope*, or its steepness, which can be defined as *rise over run* -- that is, how much the value of function goes up or down, divided by how much you changed the input. We can write this in maths: `(y_new-y_old) / (x_new-x_old)`. Specifically, it is defined when x_new is very similar to x_old, meaning that their difference is very small. But accuracy only changes at all when a prediction changes from a 3 to a 7, or vice versa. So the problem is that a small change in weights from from x_old to x_new isn't likely to cause any prediction to change, so `(y_new - y_old)` will be zero. In other words, the gradient is zero almost everywhere.\n", "\n", @@ -3391,7 +3393,15 @@ "\n", "> s: In mathematical terms, accuracy is a function that is constant almost everywhere (except at the threshold, 0.5) so its derivative is nil almost everywhere (and infinity at the threshold). This then gives gradients that are zero or infinite, so useless to do an update of gradient descent.\n", "\n", - "Instead, we want a loss function which, when our weights result in slightly better predictions, gives us a slightly better loss. So what does a \"slightly better prediction\" look like, exactly? Well, in this case, it means that, if the correct answer is a 3, then the score is a little higher, or if the correct answer is a 7, then the score is a little lower. Here is a simple implementation of just such a function, assuming that `inputs` are numbers between zero and one:" + "Instead, we need a loss function which, when our weights result in slightly better predictions, gives us a slightly better loss. So what does a \"slightly better prediction\" look like, exactly? Well, in this case, it means that, if the correct answer is a 3, then the score is a little higher, or if the correct answer is a 7, then the score is a little lower.\n", + "\n", + "Let's write such a function now. What form does it take?\n", + "\n", + "The loss function receives not the images themseles, but the prediction from the model. So let's make one argument, `predictions`, a vector (i.e., a rank-1 tensor), indexed over the images, of values between 0 and 1, where each value is the prediction indicating how likely it is that component's image is a 3.\n", + "\n", + "The purpose of the loss function is to measure the difference between predicted values and the true values -- that is, the targets (aka, the labels). So let's make another argument `targets`, a vector (i.e., another rank-1 tensor), indexed over the images, with a value of 0 or 1 which tells whether that image actually is a 3.\n", + "\n", + "So, for instance, suppose we had three images which we knew were a 3, a 7, and a 3. And suppose our model predicted with high confidence that the first was a 3, with slight confidence that the second was a 7, and with fair confidence (and incorrectly!) that the last was a 7. This would mean our loss function would take receive values as its inputs:" ] }, { @@ -3400,15 +3410,15 @@ "metadata": {}, "outputs": [], "source": [ - "def mnist_loss(inputs, targets):\n", - " return torch.where(targets==1, 1-inputs, inputs).mean()" + "trgts = tensor([1,0,1])\n", + "prds = tensor([0.9, 0.4, 0.2])" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ - "Here, we're assuming that `targets` contains `1` for any digit which is meant to be a three, and `0` otherwise. Let's look at an example:" + "Here's a first try at a loss function that measures the distance between predictions and targets:" ] }, { @@ -3417,15 +3427,15 @@ "metadata": {}, "outputs": [], "source": [ - "tgt = tensor([1,0,1])\n", - "inp = tensor([0.9, 0.4, 0.2])" + "def mnist_loss(predictions, targets):\n", + " return torch.where(targets==1, 1-predictions, predictions).mean()" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ - "`torch.where(a,b,c)` is the same as running the list comprehension `[b[i] if a[i] else c[i] for i in range(len(a))]`, except it works on tensors, at C/CUDA speed. \n", + "We're using a new function, `torch.where(a,b,c)`. This the same as running the list comprehension `[b[i] if a[i] else c[i] for i in range(len(a))]`, except it works on tensors, at C/CUDA speed. In plain English, this function will measure how distant each prediction is from 1 if it should be 1, and how distant it is from from 0 if it should be 0, and then it will take the mean of all those distances.\n", "\n", "> note: It's important to learn about PyTorch functions like this, because looping over tensors in Python performs at Python speed, not C/CUDA speed!\n", "\n", @@ -3449,14 +3459,14 @@ } ], "source": [ - "torch.where(tgt==1, 1-inp, inp)" + "torch.where(trgts==1, 1-prds, prds)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ - "You can see that this function will return a lower number if the predictions are more accurate, and more confident for accurate predictions (higher absolute values) and less confident for inaccurate predictions. In PyTorch, we always assume that a lower value of a loss function is better." + "You can see that this function returns a lower number when predictions are more accurate, when accurate predictions are more confident (higher absolute values), and when inaccurate predictions are less confident. In PyTorch, we always assume that a lower value of a loss function is better." ] }, { @@ -3476,7 +3486,7 @@ } ], "source": [ - "mnist_loss(inp,tgt)" + "mnist_loss(prds,trgts)" ] }, { @@ -3503,14 +3513,14 @@ } ], "source": [ - "mnist_loss(tensor([0.9, 0.4, 0.8]),tgt)" + "mnist_loss(tensor([0.9, 0.4, 0.8]),trgts)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ - "One problem with mnist_loss as currently defined is that it assumes that inputs are always between zero and one. We need to ensure, then, that this is actually the case! As it happens, there is a function that does exactly that--it always outputs a number between zero and one and it's called sigmoid." + "One problem with mnist_loss as currently defined is that it assumes that predictions are always between zero and one. We need to ensure, then, that this is actually the case! As it happens, there is a function that does exactly that--it always outputs a number between zero and one and it's called sigmoid." ] }, { @@ -3550,7 +3560,7 @@ "outputs": [ { "data": { - "image/png": "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\n", + "image/png": "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\n", "text/plain": [ "
" ] @@ -3569,6 +3579,8 @@ "cell_type": "markdown", "metadata": {}, "source": [ + "As you can see, it takes any input value, positive or negative, and smooshes it onto an output value between 0 and 1. It's also a smooth curve that only goes up, which makes it easier for SGD to find meaningful gradients. \n", + "\n", "Let's update `mnist_loss` to first apply `sigmoid` to the inputs:" ] }, @@ -3578,16 +3590,20 @@ "metadata": {}, "outputs": [], "source": [ - "def mnist_loss(inputs, targets):\n", - " inputs = inputs.sigmoid()\n", - " return torch.where(targets==1, 1-inputs, inputs).mean()" + "def mnist_loss(predictions, targets):\n", + " predictions = predictions.sigmoid()\n", + " return torch.where(targets==1, 1-predictions, predictions).mean()" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ - "We now have two terms which are somewhat similar: *loss* and *metric*. They are similar because they are both measures of how well your model is performing. The key difference, though, is that the loss must be a function which has a meaningful derivative. It can't have big flat sections, and large jumps, but instead must be reasonably smooth. Therefore, sometimes it does not really reflect exactly what we are trying to achieve, but is something that is a compromise between our real goal, and a function that can be optimised using its gradient. The loss function is calculated for each item in our dataset, and then at the end of an epoch these are all averaged, and the overall mean loss is reported for the epoch.\n", + "Now we can be confident our loss function will work, even if the predictions are not between 0 and 1. All that is required is that a higher prediction corresponds to more confidence an image is a 3.\n", + "\n", + "Having defined a loss function, now is a good moment to recapitulate why we did this. After all, we already had a *metric*, which was overall accuracy. So why did we define a *loss*?\n", + "\n", + "The key difference is that the metric is to drive human understanding and the loss is to drive automated learning. To drive automted learning, the loss must be a function which has a meaningful derivative. It can't have big flat sections, and large jumps, but instead must be reasonably smooth. This is why we designed a loss function that would respond to small changes in confidence level. The requirements on loss sometimes it does not really reflect exactly what we are trying to achieve, but is something that is a compromise between our real goal, and a function that can be optimised using its gradient. The loss function is calculated for each item in our dataset, and then at the end of an epoch these are all averaged, and the overall mean is reported for the epoch.\n", "\n", "Metrics, on the other hand, are the numbers that we really care about. These are the things which are printed at the end of each epoch, and tell us how our model is really doing. It is important that we learn to focus on these metrics, rather than the loss, when judging the performance of a model." ] @@ -3603,9 +3619,13 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "In order to take an optimiser step we need to calculate the loss over one or more data items. We could calculate it for the whole dataset, and take the average, or we could calculate it for a single data item. But neither of these sounds ideal — calculating it for the whole dataset would take a very long time, but calculating it for a single item would result in a very imprecise and unstable gradient. So instead we take a compromise between the two: we calculate the average loss for a few data items at a time. This is called a *mini-batch*. The number of data items in the mini batch is called the *batch size*. A larger batch size means that you will get a more accurate and stable estimate of your datasets gradient on the loss function, but it will take longer, and you will get less mini-batches per epoch. Choosing a good batch size is one of the decisions you need to make as a deep learning practitioner to train your model quickly and accurately. We will talk about how to make this choice throughout this book.\n", + "Now that we have a loss function which is suitable to drive SGD, we can consider some of the details involved in the next phase of the learning process, which is *step* (i.e., change or update) the weights based on the gradients. This is called an optimisation step.\n", "\n", - "Another good reason for using mini-batches rather than calculating the gradient on individual data items is that, in practice, we nearly always do our training on an accelerator such as a GPU. These accelerators only perform well if they have lots of work to do at a time. So it is helpful if we can give them lots of data items to work on at a time. Using mini-batches is one of the best ways to do this. (Although if you give them too much data to work on at once, they run out of memory--making GPUs happy is tricky!)\n", + "In order to take an optimiser step we need to calculate the loss over one or more data items. How many should we use? We could calculate it for the whole dataset, and take the average, or we could calculate it for a single data item. But neither of these is ideal. Calculating it for the whole dataset would take a very long time. Calculating it for a single item would not use much inofmration, and so it would result in a very imprecise and unstable gradient. That is, you'd be going to the trouble of updating the weights but taking into account only how that would improve the model's performance on that single item.\n", + "\n", + "So instead we take a compromise between the two: we calculate the average loss for a few data items at a time. This is called a *mini-batch*. The number of data items in the mini batch is called the *batch size*. A larger batch size means that you will get a more accurate and stable estimate of your datasets gradient on the loss function, but it will take longer, and you will get less mini-batches per epoch. Choosing a good batch size is one of the decisions you need to make as a deep learning practitioner to train your model quickly and accurately. We will talk about how to make this choice throughout this book.\n", + "\n", + "Another good reason for using mini-batches rather than calculating the gradient on individual data items is that, in practice, we nearly always do our training on an accelerator such as a GPU. These accelerators only perform well if they have lots of work to do at a time. So it is helpful if we can give them lots of data items to work on at a time. Using mini-batches is one of the best ways to do this. However, if you give them too much data to work on at once, they run out of memory--making GPUs happy is also tricky!.\n", "\n", "As we've seen, in the discussion of data augmentation, we get better generalisation if we can very things during training. A simple and effective thing we can vary during training is what data items we put in each mini batch. Rather than simply enumerating our data set in order for every epoch, instead what we normally do in practice is to randomly shuffle it on every epoch, before we create mini batches. PyTorch and fastai provide a class that will do the shuffling and mini batch collation for you, called `DataLoader`.\n", "\n", @@ -3620,9 +3640,9 @@ { "data": { "text/plain": [ - "[tensor([9, 3, 6, 8, 0]),\n", - " tensor([13, 1, 14, 4, 12]),\n", - " tensor([ 7, 11, 2, 5, 10])]" + "[tensor([10, 13, 0, 4, 5]),\n", + " tensor([ 6, 14, 7, 8, 9]),\n", + " tensor([ 1, 3, 12, 11, 2])]" ] }, "execution_count": null, @@ -3640,7 +3660,7 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "For training a model, we don't just want any Python collection, but a collection containing independent and dependent variables. A collection that contains tuples of independent and dependent variables is known in PyTorch as a Dataset. Here's an example of an extremely simple Dataset:" + "For training a model, we don't just want any Python collection, but a collection containing independent and dependent variables (that is, the inputs and targets of the model). A collection that contains tuples of independent and dependent variables is known in PyTorch as a Dataset. Here's an example of an extremely simple Dataset:" ] }, { @@ -3679,11 +3699,11 @@ { "data": { "text/plain": [ - "[(tensor([ 7, 19, 17, 13, 25, 15]), ('h', 't', 'r', 'n', 'z', 'p')),\n", - " (tensor([11, 9, 23, 21, 3, 16]), ('l', 'j', 'x', 'v', 'd', 'q')),\n", - " (tensor([12, 2, 18, 22, 14, 24]), ('m', 'c', 's', 'w', 'o', 'y')),\n", - " (tensor([ 1, 0, 20, 4, 6, 10]), ('b', 'a', 'u', 'e', 'g', 'k')),\n", - " (tensor([8, 5]), ('i', 'f'))]" + "[(tensor([ 5, 21, 20, 13, 17, 7]), ('f', 'v', 'u', 'n', 'r', 'h')),\n", + " (tensor([ 4, 3, 9, 18, 11, 24]), ('e', 'd', 'j', 's', 'l', 'y')),\n", + " (tensor([14, 22, 15, 1, 16, 25]), ('o', 'w', 'p', 'b', 'q', 'z')),\n", + " (tensor([ 2, 19, 23, 8, 12, 6]), ('c', 't', 'x', 'i', 'm', 'g')),\n", + " (tensor([ 0, 10]), ('a', 'k'))]" ] }, "execution_count": null, @@ -3700,7 +3720,7 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "We are now read to write our first training loop for a model using SGD!" + "We are now ready to write our first training loop for a model using SGD!" ] }, { diff --git a/09_tabular.ipynb b/09_tabular.ipynb index 62962dd..331aed6 100644 --- a/09_tabular.ipynb +++ b/09_tabular.ipynb @@ -152,7 +152,7 @@ "\n", "In addition, it is also valuable in its own right that embeddings are continuous. It is valuable because models are better at understanding continuous variables. This is unsurprising considering models are built of many continuous parameter weights and continuous activation values, which are updated via gradient descent, a learning algorithm for finding the minimums of continuous functions.\n", "\n", - "It is also valuable because we can combine our continuous embedding values with truly continuous input data in a straightforward manner: we just concatenate the variables, and feed the concatenation into our first dense layer. In other words, the raw categorical data is transformed by an embedding layer, before it interacts with the raw continuous input data. This is how fastai, and the entity embeddings paper, handle tabular models containing continuous and categorical variables.\n", + "Is is also valuable because we can combine our continuous embedding values with truly continuous input data in a straightforward manner: we just concatenate the variables, and feed the concatenation into our first dense layer. In other words, the raw categorical data is transformed by an embedding layer, before it interacts with the raw continuous input data. This is how fastai, and the entity embeddings paper, handle tabular models containing continuous and categorical variables.\n", "\n", "An example using this concatenation approach is how Google do their recommendations on Google Play, as they explained in their paper [Wide & Deep Learning for Recommender Systems](https://arxiv.org/abs/1606.07792), and as shown in this figure from their paper:" ] @@ -9751,7 +9751,7 @@ "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", - "version": "3.7.2" + "version": "3.7.5" }, "toc": { "base_numbering": 1, diff --git a/12_nlp_dive.ipynb b/12_nlp_dive.ipynb index 2fcb33e..110a895 100644 --- a/12_nlp_dive.ipynb +++ b/12_nlp_dive.ipynb @@ -2343,6 +2343,31 @@ "display_name": "Python 3", "language": "python", "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.7.5" + }, + "toc": { + "base_numbering": 1, + "nav_menu": {}, + "number_sections": false, + "sideBar": true, + "skip_h1_title": true, + "title_cell": "Table of Contents", + "title_sidebar": "Contents", + "toc_cell": false, + "toc_position": {}, + "toc_section_display": true, + "toc_window_display": false } }, "nbformat": 4, diff --git a/19_learner.ipynb b/19_learner.ipynb index 171d96b..9e7bd9f 100644 --- a/19_learner.ipynb +++ b/19_learner.ipynb @@ -2,7 +2,7 @@ "cells": [ { "cell_type": "code", - "execution_count": null, + "execution_count": 1, "metadata": {}, "outputs": [], "source": [ @@ -21,7 +21,7 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "This final chapter (other than the conclusion, and the online chapters) is going to look a bit different. We will have far more code, and far less pros than previous chapters. We will introduce new Python keywords and libraries without discussing them. This chapter is meant to be the start of a significant research project for you. You see, we are going to implement all of the key pieces of the fastai and PyTorch APIs from scratch, building on nothing other than the components that we developed in <>! The key goal here is to end up with our own `Learner` class, and some callbacks--enough to be able to train a model on Imagenette, including examples of each of the key techniques we've studied. On the way to building Learner, we will be creating Module, Parameter, and even our own parallel DataLoader… and much more.\n", + "This final chapter (other than the conclusion, and the online chapters) is going to look a bit different. We will have far more code, and far less prose than previous chapters. We will introduce new Python keywords and libraries without discussing them. This chapter is meant to be the start of a significant research project for you. You see, we are going to implement many of the key pieces of the fastai and PyTorch APIs from scratch, building on nothing other than the components that we developed in <>! The key goal here is to end up with our own `Learner` class, and some callbacks--enough to be able to train a model on Imagenette, including examples of each of the key techniques we've studied. On the way to building `Learner`, we will be creating `Module`, `Parameter`, and even our own parallel `DataLoader`… and much more.\n", "\n", "The end of chapter questionnaire is particularly important for this chapter. This is where we will be getting you started on the many interesting directions that you could take, using this chapter as your starting out point. What we are really saying is: follow through with this chapter on your computer, not on paper, and do lots of experiments, web searches, and whatever else you need to understand what's going on. You've built up the skills and expertise to do this in the rest of this book, so we think you are going to go great!" ] @@ -33,18 +33,32 @@ "## Data" ] }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Have a look at the source to `untar_data` to see how it works. We'll use it here to access the 160-pixel version of Imagenette for use in this chapter:" + ] + }, { "cell_type": "code", - "execution_count": null, + "execution_count": 2, "metadata": {}, "outputs": [], "source": [ "path = untar_data(URLs.IMAGENETTE_160)" ] }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "To access the image files, we can use `get_image_files`:" + ] + }, { "cell_type": "code", - "execution_count": null, + "execution_count": 3, "metadata": {}, "outputs": [ { @@ -53,7 +67,7 @@ "Path('/home/jhoward/.fastai/data/imagenette2-160/val/n03417042/n03417042_3752.JPEG')" ] }, - "execution_count": null, + "execution_count": 3, "metadata": {}, "output_type": "execute_result" } @@ -63,9 +77,16 @@ "t[0]" ] }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "...but you could do the same thing using just Python's standard library, with `glob`:" + ] + }, { "cell_type": "code", - "execution_count": null, + "execution_count": 4, "metadata": {}, "outputs": [ { @@ -74,7 +95,7 @@ "Path('/home/jhoward/.fastai/data/imagenette2-160/val/n03417042/n03417042_3752.JPEG')" ] }, - "execution_count": null, + "execution_count": 4, "metadata": {}, "output_type": "execute_result" } @@ -85,19 +106,28 @@ "files[0]" ] }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "If you look at the source for `get_image_files`, you'll see it uses Python's `os.walk`; this is a faster and more flexible function than `glob`, so be sure to try it out.\n", + "\n", + "We can open an image with the Python Imaging Library's `Image` class:" + ] + }, { "cell_type": "code", - "execution_count": null, + "execution_count": 5, "metadata": {}, "outputs": [ { "data": { "image/png": "iVBORw0KGgoAAAANSUhEUgAAANUAAACgCAIAAAAUzb6mAADk7ElEQVR4nHT9WbAt6XUeiK31jznu8cznnjsPNQMoACQAkiAlkiJFSe6W2WyJVsshdfSDw9H2ix1uvyjC4SfbHR1+aClshUMd0WoP3W2FJtKkmrMAkAWABApAoepW3aHueOaz5xz/afkhzzl1ScsZO87dO+/euXNnfv+a17fw//R//i+FEEIIxhgAIKIQgnPOOUfE7i8ihhCIKITgnBNCEJExBgDiOE6ShHPeti0AMMa693vvjTHOubquGGPIiDHGGEMkRAQAAEYBERkRNrWp69b7wJks2znnnL2ydefTnQARIWL3LQAQQmhdGcdpFMU+gLPgfXAuGBdca6SUOpJKcGRA3hF5IkIBUkrGeQjgvQc4P2EA0FprqQC6N1P3yx16zjkRNU1T13UIQWsdx7ExhnMuhOiuiXOuOzERfPcyBIeIDAAgAIQQAgKVZZmm8U//1E/9F//Ff76zs3P//v22Cd57a6211ntHRIQAEACDkDJOdJqmaZomeZqmaRRFm7FujbPWAhdKayaVD8E511rjnHG29d4CBQaByEMgNRo45wBASimlVkJqHUVRJFAQUbGqptPp9as3rLUAAADOUVGthmsDAhvISnRtsdwcDtvlMpWxFJoYbwO0CAa4o9BySUQAgTHWoQUwEJGUEgAQ4bP9AESei34Ivq3rqlhZ0whEJCLvfQgBAIQQHYwukde9oQNfCKHDBBFd4rX7q7UGACLq/l6+v7sxHf4QESB0H6mqBogxxhG5d+ScZ4wLyYbJsDtC99kQgjGGMaaU6i7QJS47LOZxLoTqPoIMMCARedsqpYU8f1vwAUIgCgCAgCF053B+HM5ld26CcYAAgUIIHAmRcc5coBB8CCEED0AAFIK31rRtc3kyHYCJgnMeyRvTlmVZlmVVF6ZumqZyzk2mZ/PpDJF+7dd+raqq999//9vf/jbnPE36QgilVJpFURTpKJKKc85v3LjGxPlKDBi6i4yITbGy1rbWegNFUxKh9c45Nxj1leRJnEVaRUoIwRgSQMA4MsZ47xE4AEBAIYTkvGnq4MmZypvWu4YCdV+RRLEQGAm+LFZC+HyQq2BNU5FzjtrgvA/QEjgheJyqSDOuu5vOGGMMOlSEEIQ8hwdj2O0EACJRVCulVJrqLJWcobj8wKX06sDXHfQSTN12ecWJqJOCF8LsM8x1aDbGtG1rrS3qqrtwjMOl/ENEFUchBApIAT0ED0REnohdXOhL6Hdn1R25O9XuZfelnsCZ1rvgPTEmGAqAAABFuRRCKCWk4JyjYCiEYBw8hUtZTgGJCLFhjMVxbNExDkjgvbPOd5ePOHW/yDnnnSMiB4GCy9K0bduyLOu6bpqmLMvValVVVTGfGGPqum6aqmkaY4wzrXMuiiKkoLWOomhtff0LX/iCMWZnZ6fTPJwj55wQvHfe+0BusZoJIYRkKDiRv/y94ziOVJzwjEkhhGScI2eIyDkD8iE4hMAgkHfkrfdWC5DBSwQhGAIHQMZACIrTmAgVElk77KXBnyso17pBnulYx4rSTG2sD08P4PDp075OyBqOuLm5MdrahUifLVYn04nlsrvgHWwYY93ZIiAyuriJgIjd+o8i0etlg16uJOcIohN43bXmnEspuyvS/eDLZdfhoLsT3vtXRZQxhojqur7E3+V+a20Hmksxeala0zQOAYIH7wOivfy6c3l5sV2IKF5VVXdwROze030RegAAZ71zAZELrkKgENxw2Oecc9apaeeddd50eqH7LZxzFOc45hzqagUAQjKlFEe0YJ1zROTBW2vbtj0H07luDc+ePbPWdsvMGNNp57ZtR4OcMRYpPRj0+4MreZ6nUSyEcM4xxrx1aZoioo4j5AwAymrOOeeyM4HgXBeBX1sfCcGFVt2yuRS0YIzgqgNrCMEH6G4zY0CBBKFgTCulJReMISOFvFO+UZRwLkIIARhjwhofAq1WcSzF9vqo28sYWy0KKTnyEA3S8bg/7Gd2OZsAmGpF1omYlBBZogKXFKxpK573iboF0NlsFAICBCICIkQGBAT+Upz5YKxr6gaq0lnTCCnl5Z2+NPuIiHP+F+Rf97xpmktEdnLOWiulbJrmVah1QOGcZ3F+gWNijHFxbr2VdQXEGBMACAyRMwCGAgU7V6Yd0Dt8dKdHhCFQpwQvsa4jxRgTjHuw3tgQAgJHhLoqhRBScs45BE/giQIReWO994iglELEDpScc6VEXdfLeem9b01dVVXTNCGEqiov5FnToa1tW+dcv9+PoijLsq2NcZqmSZLEcayUCtSEELz3EAiAdecJPqxWZdu229vbgVyWJ1LoPOv3+31gmjEmpVRKKaWEOle6VV0Q666zD0CeAhFDQCkFl7KTGjZ4CAGRJONRrKTATOs8i3pZmsRSSc4Bpe/MKsWl8I7quq0bEwI1xjkX0PumlLEUzjmGDDgb97Omqaq6ivNIcVYXK980nIFvXCSkFGJydnI0OTXIeJKMh/0pyUvhxTlHBp3d5b29VKTnEhGRMZb1Yx1JDlQbU9Wrz+RfB4tX7bwOdh0ILs3/S0B0TkZnO3f38hIoHXY72zxw7G48ke+0ZwdNrXUIgQKEQD5Y5wwAAwgoZIe/S0nTHTaKokvcw8VGRNY7xZUQPITAATszDpGXZYnkkASJ7kd5wAAAWdIry7Ku6tVyXtdluVq1bY1I0+l0OpvMFgsfbHdkJrhSKo61lDJJkvWN4XA47Pf7cRxfClFEtNZ2kq9pi9Zg064u3DglpZRccMGA+HhtyBi7d/f17oevr6+PRqPFYrG5tUVEBOfX9/xXs6DjCM+tJ7pUTZzzYLE7sBACETlHIYQUDMknWg56yaiXJbHmGLxprLUREXlAREBmwLHgwTsi0JyBBwDw9lxTITjGGKcQghOSb61v5L346OBguVwuF0UihHUBGgOOmuAt5/041klMxbn4QuSICARAeOEockSOGLynS2CU1bxpOTlblUVTl4Ix1sHo0qXoQPbq80v5BwCdK3ppBV6aZZ05eGkgXkKksaa7vudWAgHnHDFsbe+1bVvXbVU1oW6sNyFAABmc7X5QCAGAOqnJGPPeXqKfMdaZnd3t735rcB5CYMBa0zrnBnnunGvbej5brlarqiqstY4CtmE2m62KhbfG2KauKyCvlHr9zde0gkGu43SY9/tpmmZZlmRpv5dfSvROsDnbWFMvl519qZRScSTzLO7sFmKjEALQpXPGOuNtsVgI5EkaJWk6XywGw954PG7bdrFavqp/gDPGGGciilMpZScXubp4wjkQf/VkQnAIEDxAcJ6HzpMLznME9MgIXGOdcy4QIvoAIYBSETJe1o0H8i5YHxrjrA2EgTHGjVWxioRMsp5QMhBDpgGlDax1ThHPkjyLohbRAJ4tVsD1K3ZapzMDECKc+xIADIAR+S6UIeUAkYIzDHiktOhk0rmLdP4BICKtdXddXo2GdPe7w9+lsu7Ux+VN6kQmAHSCs3sOSIwh51wIJiTjnGd5whiz1gKE0EVGEDjnHM7FML4S9HnVDLj0fM/dII0YyJrWNq23zllbrZZVUU6nU29t01Srqqzr2jlDCIyxO1fvtE3BwfcG+bC/k2XJYNgbDgebm+tnZ2fz1RIYEkDVNsbYVbFcLqZKqTiOoyjSWsdxorUWQly/fvXSPOjM5S6GomIdQujcHCIKPngKwXshxPPnz9fX19/+hbeV1NPZbLlaSalTlaLgl/pXSskER8ThcMjkZ3ExOlciQHT+EhlqyTlnnIFAAGc5hOCoWLRm1TAMEFxwVlBojXPOAbAADJAJpQUXxjMTfOuhcWQ8GBcIkTHMdSIiXdbV8dlcSl62Phusr+94DKSZSLJUxvHSmrquUWqd9cFHF8oXO73nPffehhCklFKJDgmdwyqEaF2JgEAA4ICkmM/n3Tru5PmlAdcd69Lsu0SAlLKLFYWL7VJrv+IBUfeVRCQ4j6JoOp1kWYZAq+Wy38/LVfHxR/eTJKnrtq5ryRlQaNu2l+fOWMZ42zTOuTRNOedN0wRyABC6gCFnRL6q6rquvfdn5VnTNFWxqoqiXpV1uWqq2hu7Nh5tbW1ZRhujHlGeZCljbPfq3jgbaimrqihWC+9tcG1bLuahPj16ppMYEImY0nqgMxQ8z/pcsi7OJ6W8hAIRtba5tHsQgTHkwAh5ZzV67531EAJDIYRQkQ4hbG1tIeff/e53f+5n//Jrr72W5zkRoTi3ZKSUQsm6bp1zcZYKlQIAEEM8twjP7SKuLwMCIQQgjwAIIIRqmwI9AIba1JyR5NjWdaev6toGIKnjEHyoqzjjgWmhdDZkWe3ibNiPozzve+8jCAQwEhggBISro3XfGKl6zaoMzgWA0vPWC8sj5LIBrqTsFl53npfKMIqii/14ecLGGAKJHBAAyCKQSJKku7iXQcJuu3RI/4IW7oB86X90aHPOcc47W/DSC+nuTVnVVVVpHRER56zX6zVNzTkfDvv7+4eMMefC4eFhmuQbGxuTySTWEeeR1ooxrKpytVoZY+I4ruu6ruuqquq6LsuyqqrOoyzDkiEqLuJIb6z3873tSEvFcHNzM0vS5XJZ1uWiWCGw2WLu2+r52SRNIsZQCTbsZVLkAEFrqbVurXHB6zSTOi7qunVeSGYvbNBuTbKL0Heappf2bndxrbXe+2E2CJ4uTRGB3apmjLHFbLm2tjY5m/7ogx9sbm5aa6uqIhBCcEIMwBEll4xLSJNccEEIiIjACRgBYxwZB+MCA0REBhyRAQpEQABPlqEm8tYbZ1FAQMk4S2pn0zTvJdwDcSatD4FQRrGtmoCQ9qOrOtvY2KzqFhEDuLIsvPdtMAFovLY23titinL/5YkBHogRAoFwnHlC4MoLHZxDJM7P0wRE1AWOiUgqEXF9gZZzG88FjoguNIJ7JCa01t36fjUQ2K3IV53ZS0dkuVxqraWUndXYgaxzIS+VZicAunuQp9l0diYTsVouCXyaxovFfLw2XC2X49Ggqc3KrNZG46ZpXr545pzbX87btl0sFnVdI2LTNE3TKKVCCEKIztPMe3HeizuxPd4ZOefIGnCWU+AAGDyncHrwvIi1UipWPBoP8jw/POa3ru8KJjlgXRXONlpwCsZ7iyFIIZFxAkkI3lstVZQqrTV24eCLyNSl1dHv9y/tnk7FWGudc55cCAECdeYOIgcfvPdta1dlsbOzs7m5+fEnn9y8eZMjXru+N1s2XXTGUQDGhWAAgIwDdiIVAbELZTDGGWMagBgyxgSe29kIASGQ4SQhmNY7BOKEHIgzDoyr3nBbRbqu67Y1bdNUbVubqrHOeZ8kqY7SOMmKpjXGEtFsMkHOGmtaZ5GJjY0tY6loLHnuyRMiIPcYAleMqyA0etf9UiFEpwgZY1KJEEKHqws4YifCFU8BwDHOEIPTolOgly7I5Vq/NAcv1WuHv/X19c77K4riVUXc6XF5ERpwFxurGgyohVSDYdNW3lrJOAcc9Qenp6fvvffe0yfPtdbLZTGfz/v9fpzFWZaF4Im81tFgsNH9vDt37kgpoyjqcn1FUXR5kZPJPhExCppzKUUsWCQ0QxpmEeeYJAmTwgXiQgTTmLZiUgkh44iLJI6URNJAPk3Tk7PT/nCcD0c2QOMozntJb0BEJHRn+3bg6/7iK/Hwc2vMuUBIwDAwYtTtDf7c90dCrTURcSnW1gZPnn5qbJvE6Xy5lFGqtTbGhMYAAFyEAJngjLPzWCwA4rkVHkXsXLJeigznvTNt03pPVVWRtbFiAahqDCIZoSwhC9gY35rQtH61LKvWSCmDp7Y1bduGENq27fBRl6WKIi44te3p6amUiiPzPiAhdQ8gQk4sEENgyDkC4EXUjpCBkFxrnabxpeTqTMMuKuy8CiFAEKRUYEy8irnLOMsl8i7xBxchvS7W0J3xqy5Lp8Evb8+lT1euqqIovvvt9ybTs8ViFsf6Z3/uZ67sbj/85MFv/dZvPX/+vN/vx3G6trZ29/adqqqCcF/60pfG4/HLly9PT08RMY5jrXXdFHUDRcm61dJ5SEmSDDfuUPCd8BPBCyDuPZDtbg5y0pF0wTuiPFPDPGrbVmupuBIcOFJVtNa0nNHVvR1jQ6zlWn/YBg5c6ThxARwX+EoY/NIPC+RejY36QD6Q80FJ3UlE55wPjog4F0KINIqvXLnSWTtf+tKXtre3h8PhH/3RH6ngAsXW+sa0nRUeAjoyzDPGEIWQ6hW7MwCCJcIQuqSCoBCsa03T1m1pq2o2mUCwm+MRQypXS2tbyyNELqU0xiilulwhOUvIOtPt7PRESZGmaRynTdOkkQQWmOA8iRtrVvN5rHQWRU3ZAAIgC8g4OE4ESAyJC9bBDhkwZIgURSqONee8C6cTkZBMSumc88FyxGAdgQPwgYy4tGk6eF1undq+tAgvcdbdfkTMsoyImqbpgNiFwWaz2dnZ2enp6Ww260w3MmEwGNRNub6+1s/yXj+7fePm7Rs3nz359LW7d65e2c2zHufcuRBF0dUrO/Ewvn37ZgjhxQtvTMMYAwhtW9+4ceMyQtQlJDqjoCxWDFEiCI5KcoVBALAAXW5nOp1GWgZjyqqOFVeSpUmPiGxdeAiRVmmiexvDzc3NazdufeuPv310cLirYybTqq4BpYoTUupyLQEiIXoAINBJeom+EAIKC1ygsMyfXzHOOEqOAJ0O2j86PNg/rOs6juPxcPT+++9vbW28ePFs79YNGbgL1vlGIedC2Na0ZduKkisdhzilXGsNDH0g55ynNoSAyEJQFKIQQl1XdVVh8JZM2axY8MBHnEHrWmMb8LxYLLtlo4XkjEkEzRkDn6jIYtAQNLpcs1QzMJ4iUTU1Ga+V1CrSWinOjZNMO2cZMQyCOULlATgIRhi6nD4xBt3y7FwD5yjN4vMoLxEiEgXOmeAYCJzxXX2DeNXJoFdCu51QvHRyL7MRIYQuFaaUWi6Xjx49evz48WKx6PIfdJH2UEp16QFbtt45wfhyvgjkilX83W9/p6nLpqrv3bl7fHw8mUzyvCeFyLP8nXfeOSmPZ/PJZDKpm3J7ZzPP887FqeqCcx51W6xkw40xIYQ0iRiBAOIQGDlvjW3bYI2WfGN9TTDY3dlAJk4nZ0nWu3J178btG8cHhw8ffDw5PVotC3K2KSMgf/PmTSF5HOskinmUZlLHad8RFISXku9Va9h5egV/5Pz5QwE/NzwuVKRzpmnc5uZmW9XrG2vOOevd/fsffvLJ/V6vV1ZzZL5LV+qIB2DGlsvVSsURa2tj6hAcsVxK6Vyw1krhEAICZ5wLSSEQ44QYuACpEJj3wTFOjCMTpLniPOlCGUpyJbn3HiFIwSQXHANwyBKZxVoy4BASwQMjpkVgnICAQS/WnAlqGhlpJ5wncgKdR4NAnBQjxjAEvBBVwRhTVQ4Rd69sJ0kSRdFqtVytll3kREpZNVXTVG1bOduathYdqi792Usp2OUeurx7t11qvS7hluf5uYYty/l8flmf0rnD1tqiKIholA2KotjYWPPeEfA0TQ8PDze31t95553lchlF0dramrVua2srjtJnz54t/az79n4/T5KkOw7nvHte12Xb1pfmVwdNQGLIFGOSJCBRcIHYT33tq7u7uw8fPrxx8+bR6enDh5/MZrOzs5O1tdFiOauqEgIpJSzZslwdH/vf/M1/DUxdv/P65uamZzobjAjloydPIe135vN5fB+AKBAFzsUl/hADEXYXj3n0zpjWCsmljAGobWxRLk9PT5uqIqKjo6M8T3d2dp4/fy6E2D940e/3iQiIqUjpWPtgjWl0ogm888YFB0CcM0QgYFqLLlcbxTpJNBESeCDblBUiAZD31gULiISglMDAGRJjrItfmqZWQiopFBfOGQBKI51FGskJ8DJR9ZTyQV9qNVsVdWMEghas7cwPhABkOEhkgpAQOIPzWwABIDgXyrIsyqUxRiruveec7e/vv3z5kohGo1G/nxPjVVXYpg3eemdE2VTdCgYfQjgP9SFBHMeI6KzHAKmOHHdEIUmSk2W9e+32alnMV40SqZB961Te22jruktXIDhAQgYABACzYiakMM40damUaqq6l8TNqvzv/5//r//kP/mPf+f3f+fn/vJfQiRCePTk8cvTF7mIWmPyrB+cExJM7TaG61GSAmOnk7Ner8ek8BSYEG3bCiGmjRumUrQL3c4iM4/dKua2tjP3nJVme/nk0Qf7P1iVZdQsvffSqPd+q75y9dpY6imqyWy1WJkoTkqnQIgkzxrMlg3xKJRnJ1VV9Qe55dp7r6QQQlhrOedSR93iRDwPO0PwEDx5Z5p6cfLcOFvXdZylx4fVzTu3iRUnZ0/7vcFkcUQv3c7mzu2bt9771nuSyd2NndVJK5Ne5/AxESOPODOMCR4EAPSjXBLXDvdGmx9++OHVq1eRQRzHzjnyIRM9BGqprtqQqmRSlBylZ9Q6bCwtmnB14wq2zXmAQpKKmNDaQmNbwxULlvey/MXR8w3YEFyQYFVd87W0sKYfR8V0VbVNebjc3t5eurOqqqSUiNTWJopUn9rVpLg2uvOHf/qtpjHXr167d+/ewcHhi4ePiWi5XN7dWGuO2vv37wuh+lF0uH8YAmytb7d27lYzW5ZpHEuhRdua84Az4KWWYXCRXRCCnO8qXEIIZ2cTmfbLsmxNI6XkjAvBlBJl2V4Kv65q6fJJvzdo2rqu67Y2ACAYvnjxoqoK5+1yWfzyL/+KjhWR/86fftcGZ4wZb+5SwNH6GhM8TdPZfB5nudTKBB/XjYojJrhxjjGGnANj/d4wkUEwFzMTccvK1lujZPTo4afzVT05W3DdtM4jiBBcFMUO0HtCJrJeX8W9Xt9wpa1HHkUyipTUjsi3lhA4F3GcBC+FuAzBXOaE5IU1Yrt0IOdI1FrrW2uICDgDhkxIBMa4UDpywbtAQoi0l/cGw6s3rgNAa22vl0nJ27px1gK4SLGQRG0TBzKjwRiRIFhAX9Xlxua64MyT89YggFSCwNdtBcENR/3j48M0jfM8PT2tuGDr6+sU/HIx70USEAEIMCAj8BCCc8FGTDlnmoYBBhXJKIo4Q+9t0xrv/Y8/uh/raDQaHR4eff/779+7d69YVau6bG1TlEvO+Z17t5kQjx9/2u8PXzz9sUCxvrbhbFcYhbu7e2dnZ0mSbW5uF0WhlLp1525bN0+fPpURLFfValWcns2a2ojP4iyX5Y6McRSc86oqer3exngtjuNeP+sMvqP5cn9/3zkTRVFwnnOepmlVVUTnlSmIQAGQMYBAhHVdG2NQySRJ8l66tbEenNNaai2/+c1vykgW1eprX/va7u5ulCRAWFSNirTUSioVxTGvauQsAGitZaSlVoyxAIicCe+Z4Fxq8g0C50ILHzWtL5dVooTzvKl9HPVMIO8aIWS5XPZSXlu3WBZ13ViPyERtHFqojDXTOZOKkEezXCgptZBS6iRlKlZdtQFBoqPO+xFSeuadc+Q8MA4AHlAgYwQ2UHcxAzAVxcCQcal0nOf5/sHRYlm83D9UMkqydO/ade/9bHHG0DFOGpiWDMCbtqqqlVaKi+BaW1qbpGo+O97c3PSeekkm4NxqDxBW89lyuUiSRAq+XM4D2V4/ZUDHhwcHh8/TNL11/Y22bWezWTOvupoUYxpEcMECIx9s27aHh4edWVuW5fr2tiewJsxnp3/2vR/s7V3L8uF0tugPxh9//HFrm9F4uFqtmtrVra1b20tHn/vcF3Z2dmaz5WKxuHXrnjGmqqqsPzh4ceC9Pzo6yrLszp07ZV0dHh+tVivv/WKx2H95uL+/L1iXAIKLFLsHCkTougW/u7t34+re6enpclHs7u7eub29x1zzzaKqCsagtS0ySNN0sViYprkQgYjIKARkrFMrQggpFWesKhshlFAqjnUc66IoqCIdRYeHh1/76a9OZrN+v8+Iaa37gwGTQupIlKWItFDSegKGhEjIkDMmzmvmDKG1XiHnTHOhWxOmZ8uNtWGWj+Jk2IuTsmrCcsU5NvWxaX3hWzZbzuZLYxyhaB2pKCHglkBqalovooCMhEQErpjiKkqSpLM1sygjoFa0SqhVuQIGnnlCCiFAAAaMIxdSIqJHCEBpnAByD0QMq9YwqfrDwWAw8BQGw5GS+vDwEMlyVFoScUJw3jWIRilKU22aQghRTOdS4JIxLkBKWddFFEWMMXJ+VSxevnw5mUwkZ3fu3OEce3kKEJD5sloAhH4/f/HiWYc/Y0yWZUIIb2yn5ZBBr9cTSkgtvfdnZ2eTyeTBkxfj4QiRP31+8Mknj+J0ePv2xslkAiKO88F6lu3t7T57/uTkbHb//keNaXU0ms/nd+/Wi8Xi9PQ0z19Ya69cufLjDz5+/vx5r9djBGVZfvjj+/P5/OTkZDDaNMZUVRNCyPsbggi76AoQo4CARESBqGkaIcT6+vru7t7jx0++//3vv/vuu7/0S9cMQr/fO1JHQgIicY5KS8YvE3ess4IROVAAAKV058RIHTGGe3t7vSyRUsaxNqbpjwa9QY6MruxerZpme3tbCAUMk37eWONC8BQIAbnkLCDnTHDGOENCzs8fHhkTkWY6QCQ9E7po7BrI+bxiPM8kAtNaec55JGMtEm8BkDOpOEog5hlkeU/FSSAEIfM8l0rR+SrijAkK3jsrpZRSEHgCEpwBhEgr7z1QCN5554N3QIEz1JFERLDggleRvEyRe++7mABhODk5EYwjkQ8ujnSWJsH5uq5NWzEMHGjU781ms8cHxxsbG0+fPo2iKI3SZ58+Xltb857SNO1ydwBgbVuuCuecUgohENFkMtFaro1GMOg1VRHrSGvd7/e7cMHp6enR0VFVVe+++y4EaK2LklTHSVVVRyenT548SdP1YnW4v7//+PGTQX/0jW98++HDZ6+99lrbHg9H/bPJ8gc//PFkcqYj+eTJY84xSV1VVZE+3N9/sVgs1tbWjDHWhKOjI0RBgcV5UhszXFv7G//+v88Ye/zw6N1337179+5ivvr444+Fc6GrluqyOogIGJAgSaIuzRrHsLe39/jx48uqKsYAMRAFLrDLGwPARekCIp3/C3Bex9A0TWtdL8vX19d+6qd+Zn00dN4Q+fv3P8zz3Bhz7949rfV4vC6Emq4WtrXEsG4aLlXdNjKOFEOt4iiJtdaE6C0wxpjgTHAeAuOklPJNDYwD8rp1AcS8KOOed8tK6RiZQoQk6ykZCaAoT1GqQKx1Hiuj4ihOk6a1nqBt29q0PoQ4jRgDIh9JRLJZlDJgHiwDlMgIghTCsGBbj2Q5euAkOUlOCF4KyblcVU5ybk3DIORJGsdxsAYhNHV5enwSCYy0jiNRL0OiNI85ElVVNT07q8oaARaLxfNnL5umOT0+llJe3bteVRUiCh5VZTOdTufzeZZlw0FPqUiIcHJ8fHx83NVsj/o9b3xRFM656dksjmMiCkDdvahqCygfPHzShbtfvHjRJTlnsxljbGc3e/z48XJZ1I0drsVVvTw8WUwXP7h77/bByXQ2m7zcf7a9vRkl+duf++KtW7dsyweDQZ7nXXXPz/3czzGOVVWdnZ1tbGx05YmHh4fI2fb25o9+9KPpGc1m5UcfPeKcD0frXdEev2wDYxwAGBIMBgNr7Wq18B42NjbG4/WqaqoKMLWAwQdb14HCeWJAa11cAhAAUQAGAA4QlFLW2s4qMsa8EtxxUsq1tbVlsUjT9OHDh9PFvGkalSXgXCBCzpQSUZIkWRql0fl3CQ4APPDLnCMF4oxxEdq2lGgshMYZi5D0+tlguCoaFXFkZGwbRYkHEpEEwR0a49rW2FVVeQQTXABGCMYnjDECQqa5IKnQu7axdtzrA/iimAshsihrXWOMWS6X8/m8yytIKYM3pq3achn1+3GkmzoICk3bqijOxgOG3A76SRSNBsNcq16azqbTEEJTNdWqYYzNzhaTyWQ6nZZl3S31WMVNaZRMEHFraweILZfLZVkWRXF4eFgURb/fX84LIZiUUnD+9MlLrfV4PG7q8LI4qeoiy7Km9cZWq9VqPp83Tdu2LSImeTYeh65xcTZvqqrK8/z6ja1r164JmVy/cfvGjVubWztxnOo4efny4Dd+4zcm8xqRvvwTP/3XN/+9e6/dWcwnUvK1tbVhvjubzRaLxfXrt3u9XtO4qqoYg+WqOjz6oCiKoiiqqhwMBh99qJ48eSLEcL5cdR0L3vtzn4NzzlgHPuiK91++fN4l+DmHLqurlEoSqMBLyb33TV1zFASec0ySaPoK/i6z8gC8bVspZaREHMdt2zZN5UPGGCgVAcD+/r5QnHFI03RZLuNYx72UVai1gha5ksjIOdO2nDHmg/VeMsYAiQsmiUspBHcicCmoptaSJQEeAQSP0jju909XpWYYGLTeCa2AIQmoXTUv521rW+PLphGRkKTKqpFSBrLIBBBZV5UVLpbTly8Oq6oq70zyPH/w4IGUcnt7ezKZZFk2mUzOzs4AYDwe53leluVyPm2LOcvjRCQrCOhNaJokzYa9HmNsNTmdHR9R25TLuXCmmE+SWJPXy0Uzn89fPnu+WCyIIMuy0WD04Ycfbm5uHx9NQwimddOzMoqiD3/8YDGvJpPJyckJEfV6PcDAAPM8N6bVSu3u9s5OF4f2bJD3EHHWVtZir5dvb413rvA0TdMkGwwGGxsbm9tbzp3n9Mdra/28b5zjnDd1mSU9R0QBGI8I4PGnLze2ry2Ws43x2i/98l9DCINemud5L8lmy8nx8dnm1laSpKvVSqs4SZIkzg6ODn/vd/9oPp/u7Oy44ItieXo2Q8Tt7e3WiNC2XMpeFAkhRFmWeZ4jUtO0jEMUKedssVqlaVo31XI573K7VVUopZwDLnkc6/l8mqa5QME572pXuxIsAAACZARw3oQihPDeCyERgXHoomjOWe9tFGsP/uat63Ec7x++rKpqMBjUVRnFkXMujrUxhjGQgjEKURQN+73pfLG5udkaI4RYmlYyBBF8XRvrs1w30xUTWNi6sM20qgtL65tbV2/efPn8GQbTFJUWUqfRbDGPssgGn6fZbLW8eefmYlkMxwMudSB3dnZ27dq1xtbG4ouXT5bL6oMPPjg8ehlFUVVV1trJ9Or+/n4URV0HdJ7nquBNW9Z1vVqtelox76rlIlNqkCSJ1AeHB8E4IQRZ//D+xz/9ta8agB99/3u9PD1YrY6X0DVrNk2TZdnrr78xHo+n0+li3hy8/Ihzvrm5ubGxc/+Tp2dnZ7PZrN9bi5Lh7bube3t7rjXj8XAwGKyvrw8H/SzLujxHFEVd8P/KlSuj0bppWynl2dnZ+sYGABIQAgY4dzo9IHbaSpAxplhVx0eTumnXN3eldpPZUke9JO0ZG6rGEpOxFgBCCg2ASZwN4j4QkyIWoiVCZEJITJOe1tF4bbNpnTGGUGa90fr6OiLqhEfR+re//e0ukyWyLKuqKgSnJQfrV8VUSpllcVkuEbnzLSAohVEUAUAIYINlTGittdYYut5BLoSIY31e7YyAyIRgiLxLThTlynAxGvaUUMY0jOXj8bAoV4xBIDo7O7l+/aqUIoq1dUbHEik403IEgsCAGBBnNDk+ynr51trQmtY2jUySRCtrWpX4wShHU7nAnRYyjmSaHk9nr7/5uVVRHy/m6uz0eDF3bTXoZbdeu/tgVQSGRLC3tm5al/V6gSEK/PH9jzY2N7XWranni6lQvG3r+TwcHpxqLYn8j370g+l0urm5mefpdHp2cnICAEqpXq/X6/UQsSiK1Wq1GfHPvfuFYlmWVXt6Mq0ak+f9BS6ISEnZzweSyePDkz/43d/b2dnCQA+P3Ouvv75amqYxb75xF0G/eHZy887t//Gv/p0uJ76xsbG+vq5V3F3e8dr2cNirqma5XK6Wy9fu3QaAcF4hCAQUnBdCdIpPyrRctYwxpbSQibXMe++851wabxFYCMFcZBJba41xLx5/3LatD9hayvJh1VgXiJBxqQRDBO49BUldyUoIRNj1y4dz/5UYUQBgjGtvSts16DEZiJVV27at8a7f71dt4yjUphVt24bglBJZGhO4snSIHtBlecS5BAjek5CYJBEAKAVt6AruNWcyhPMqy8vaVUQUHC9bCQmIc7a1teGNXa0WUvJADpEm0zPOMYpUkg+iJEqSeD6fNqbd2Ngo64IYUnBapYrINmVwXYLBBmOiKLJtNcgSzkWi5HK5nE5O0+2NarWYHh2Eqhhl2U99/Wez/mi+KN780luB2PHxkRXy2rV7LLj7T57RaE2oGJGvbe0+f/YiH45evjgQQgDyPO/HcTwcDpVS/VGvLMu2rQ/2T3q9njXTs9O51vFwsG7aMJ0s68p67wGasmhXy7orbEmT/uHhs96nL3/844+cp+2dq1yq4RCefOeDKIqG/cG91+6cnS62t67+L/7T/1Xb1ozBzu2vdWXeURRtbW51lUirosyz9LNkPECgc3lVGwgAhCrNRy5gAAgBVqs61kpKXtemNY0Wsm3tfFEeHU+Kxbw/GN24cWM6Wc6mq4vQvWxayxgLyEIIQIicdUUkCEEIgQEZE4xxqTHNeoP+qKkNF+iJQsBO8BMQAoXgGLHPStG6qmwA76huvfdeKKl0LGXsPZaNretV5w8RkTFGNE3V62VRrChYIt8fpADkjN3c3KrrummLuimzNLOuNa0DAMm1EAqIWWuDo4t8MXnvkZGSQgkOSM65ruVkPp+ORiNEj8iTNHKu9cHU9aqqqidPH7fOvP25twBdFKsnLx4vV9Mo0l2Rn4DgvLdtTd4CwPbWblFX4I2tymoxf/rs2XkBnHKDWPvGpkkvG4y0kE3dzhdllI1P5lVrfUA92NhpgXlnZdaviDMZx3FqDJycLhCKTz55tLm5ubV9NUkH3lsp9HyxJGRNVXPOx+s73vv5cqnj3nA4bAw9ePTs+HQupezSlWSIt0FFPNZZFEU3Nrdee+2N7b27nOvx2mbWG21t7swWC6XU9ubWwcH+ydHBld3NPM+yQQ+CM74vJQeAALAsm4ODA8bYlb2rrSUissGb1nWd/MgZ57yubeeu5nm+WMyqpmWAUvKni0UaxyEE54zWWjBeNe1sNjd1oSLdBSLqtjHGcqnJt95TQAZIgIxJLoTiITAhg9IugCcSgnnvnANE1EkSEBhR27Y6USEELRgCCQSg0NW/cCRk5yUsjEsAcC44H4TkLmDVWIRQlw4ERy6YkMgF5yDiWAOGuq6cqQBdQnEUqziRG5ujs7MpZzKOJQBIKbpqUwaMMxkCWOuDC0AXVXEcuholgmBNa0wjhFBaX9nbKsvSO7d7dY+I/vVv/EtyVkg2GPR7vYwr2bb1D37wfeMsY5imCXongFzbzM9Oy7paLBZZ2pNSlouZC0EAVctZURSr6WQ4HKZ5rnp5cGhNaIrGEEGgvDdMe+s/uv+QqVhFcb/f31obnZ4evnz2uCoWb3/lZ8uyChSOT47LKiyXy6L0/RZ72fpsWpydnTGGz58/RyQKYTjsX7nxOud8MDRpmq6treV5LoQYDAa9Xq+L53XV4JxxBgwBfVswJggYAVcyCQAEkA62Dw/PvvntD7c2118cLi1F/Z49+8HHt27d3N4bPXn+Ynd3T3D4wQ9+UFbV22+/PV3MF4sFAAS6ID85b3kGHcdcC9+G49Ojo6Oj7e3NOI6xgrIsA3otlQeqTRPHsYgVq8Qw6isllGZxpjw5Gzxy8s4LrZEjEfoAjnzwpuvm9s4QIWNCch5CaJqGcd3v9zjnzrZVVQ3zWDJQggF4IZh3AEjIAucIjAGG8+I9ITkTBBiANbVrmxUT3HuKpAzEjSUCEkIIqXhRrKTi6+OhVKwo58ZUcS9fFfOqWmodV3WZp9La1jl7ejaXvcQYR+et7eeFwV3/WwiOMd4Zf4yrONa9Xm8yOdNax1m6tbURRdFselYVy7ZtDg5WX/6Jv7F9ZZsL8e3vvLe7tzMY9rZ3NuvFTCk1m81m02VZlt57kWcc6MXTJ8iZtX4+n49Goy9/4XNa69lsVjT0+OBZosQwza9f2S2K4vGnzz968Knx7NqdjcHalpRiuHWVqfjodHL49EA+fHFycsKIta1dG2+0LRsNt9NkrTG4WrgsGe/t7b315hfXRsO9vb29vb3aiVjrum2llJwxBAgADP7iFgACEQBwPX724kXdWsaV1m1Z2o8+ebCYLxkTcaz/6I//zXw6yfLo6PBlXa4OD/e/+pUv//qv//rh4f6DRw/TNN0ebD55/kxKGSVxCOQuOseAC2Nt0zQmWGOMsU0SxSjoZHKCiFkSDwYD5MgUkoW6rgN4IjKujRUuV+WqnAM44j5QI1hMPAR0DBgheiREDEABPKHnHMkFoXgUqVVt5tNZlGVa616vN5scV0XBtsecIwCRMygQKQB5gMA4ElIgAjgvtfcUGBNax54AALSKhBCODGcRQ00BgLjo7vEgzXavbOe9ZDablNVSCf7pp4/quo2j7Ic/fF/J+OX+c4bqgw8+6G+tTSZTIhBcOX/ee9uVPUvJe718a3O9108QSQihtcqybPfKNjkfKZ2kkWlqb83+/ov+IF9fHwNAa5o8T9fW1hrbvP/+9zbzbDAYkHWMQqIVYwyDP5scLZdL7/3Z2TSEYKpSczafz589e8YHm9vr61/+wpc+uf/Bb/+b359N5uPNnS9/+We++4MfP356+PxgNhoNpE72n3/aOv7Fr/x01t9eG+/OposkyW7fvmsqMx6Px+O16dlkNpqtjYbj8TCKIs5gPFqzBmwQXEAgzRgsVlZK2eWyurhmx8vR9cp0drAlT8i1jiKVvzie7x+ccNEbbIwQMVIa9MF773+TgXvt3u15veTR4J/+N/+ViuTf/tt/++bN6/P5vD/q717dOz07a5rGBbLOeiLgGEslVMwl00lk50ah3NrZEop1pSGj4bCrvUMkrgBtAO4ZopAgFa7KKlCrI11bcsEI4owxZBaYCIAQKAAgdI3phpq6bk1M6Gy7mC2ev3ia9obDwXhrfaNYTpumYYgQCDC0bR2JhMACddwugQgCOaDPejaYUFrHgIyIVBQrpVbVSsdZnPa6ggFhTJukkda6C6BcubJj7Lgui9PT0zQVnPHJZOIdAECWJca0T58+6xofOecO7GX5YBRFUaSuXtt9+8039q7uco5t24QQRuOB1noxnfV72WDQK1dFP8/eeeetKFaHh/soWJon4/FQRXK+WjZN8+NnT69du3bRb5uGAPP5/PGjB1XZRFHkvc/z/OjoaDabVVWltZ4eTSdHZ3mUPHn0KYK8c/eNtD9M88FXv/b1tZ3d1oenT5/mvdGNm8LUK2cqHedJMmzb56PBmAJrjAfgkc6krNI0bKxvCyGE4MVyeegmJ6dHcX+bc97lFd57773ZbMY539vb+8IXvtD5W0rGJC4ob1rvpVA6OTqdjtciG3htaZT1j45PhBBvvnFTxb29a7c//PEP/+23viMl72XJzVu3/tE/+i8fPPj4H/yDf/DOO+84CgFoS25Y59rWLorVarVywbfWAIC1xqxaIdjZfHrwvYOiWL71xht5njvXkg+r1bKRMlLCOdMlHpCDEOiDdd5wgUWxPD45FEIQ8jhJCZlxoW1bY70N1K2lOxlYa2IIXb9p19CYpikXqF6ojsqNwDvr2raO0ogIKbhzUxgohAAEXWSAsc+qm41xxlaMNUwKwaNIJ526FwCzL777M2maJ3Hv+bN9IVTb+E8/fcp5AsCyLEE+ALJJrz9YG/KIRU1qQwAvy1WDnEVJbkIAwWbF/Cff/IntrbXGlg8e3L+ys8GQtNaPH3zwxhtvSOmfPX9UFOtE9MnDT6SUSZKenJxcuXLl7be/cnJy4px7/9t/hqgfP8cnL1/GaXL1+s2XB4+t8xvbW9nuV7bzXDKexLFp2ptCSMbffP0Nxti/+sNvvP76686569G1LMseP36c51s8HSVEdeEYY9uj7dlZHUW5TgaOSinXOOeMN0Utrt283tiTT56c5uNr04p+53e/9Xf/7t8d5kPHuYv0o6Ojf/kvf/+dd979+te/Ppke/vN//s9Xq9WV3avOuUff/MFw/fZwOByPx1Kotm1t2zKJUapQ2rKud7avOY9lMU10VNel4MAZnZzuX7u69Z0/KaeTwyzRWdpztkrS19fH6W/8qx986xv/8V/9lV/6D//D/+CLX3gzjaWIgGLYyNbrgVkul01Z1XXdFkYN+WpZ5iL2IUwX5cMPTuKoev78pXOOK75YTs/Ojq5e2/7LP//1lwf7jIFalbmOl4tmfXd7Vs//5P1nRDDIe8NBXzCQXJVVfTJdGOIq7gcWXR0fjNY3mhrKFglGwa6DG3sbl+Wsqcs051wYb61SsZR9b3QITRf3DcER4wwUMEbk4ziOY23aYIyRSmdZBgzrqrV+6cKqtUtjTJ6nommaw8PDEA4R5Hi00ZXWIKKUcrFYIHaEUeHk5KSqiq2tLfJRt7w4F8jZZWng7u4u59wYh0lclMtPPnm4XMyiSO3vvzzYP+qa1vL8wDk/mUy6VuQbN260rU2SLM/zR48e/cmf/Mmv/uqv/rW/8euHx0cvXrzY2NqJsoQz0R8N+/1+l5vmBG3d2KZxzkVJbJo2TlJkfDDsHR4dZ3lPKh3FCQH6EIpixTmP41jpyAfigmV57/d/7w9+4id+4s69u0Q0mU0fPHpIRI1ppVYbW5tM8ADUNnUA4lJcubqX5bmxVir11ttva603NjZCAOdcY+qzaZgvF977rivZGkdEjVsdHR2VZV03rjX26tXr73z+3du3bwOA0iLWAhn91V/5pS994Qu9fhKct0bsbm33er3VarFczitTP9s/Xl8fp5mIIyAC4Gq8sbZctvXhUdrTf/Ct31osVpsbW+PxZl3X+y+P0yQTQgkhTo4O66ZKkqRpmm9+85tPnz65e+/23utXrQdvXVfiDyEoobI8ZRAkVx2znFJKoELJA3AptZJR8EoIwYVjHCAEZ1oGxBG9MXVdg3MSRUdKA2QBgIILIbCOGYVxqYADCcYdD9a258wQSjEMnHd+AgAE770wxmgdr61tzGdLKeUnn/zAe1obb162E5+3DTtX16211rSuM/ikFAGIsfNW8+BhMpmenR4fJzGQvbZ3ZXtrN8uynZ0rw+FwOBxmWdYlHLtq/iRJPve5z5VlCRd93W+//fbXvva13Wu3gOH+0aGKdFVVOo5DCL1BHwJxzm3Tcs6nTdO2rYx0XdenkwXyg+vXrx8eT3qDtSjpxWlfa3337t2qqrrG4Y8//vjTTz9N03R3d/fWnXsuwPHpRAiRJMnWzpX5fH7/k4e7u7tJ1nv4+Ilzbrlcrq2tMcauXr/pvX/28lnTNGkvHQ6HXEhvTNpLpTznXeScD8fjy558HWFZlgEwEG/qNkqz7a31vA9tDYyDGeZpmt65c+dv/gd/U3IAoNZj17nQEZAKAcFB3djZWbG5ls1mZj6fDwdjBJGMtjc31Buf+58//PR5XbdtY+ezcj5b6kitra0tFoskjQmNtW2xbJF8tSyK2SpPs+myKMtyEyiNdD/Pyrqpy0KlSTbInQ3L5dLZ2gYbrJMqKRaNZMa20OYNeJACpAwInmHIU60kl5wTAEf0jAEBA0IC6IpNACAEH4xpjHVtIEvBem9DAAAXR1IKXhvv21YASEQBIDY3N6fTqfeUpb040VtbW8tlwTkLIfT7fURsmkYIPh6P4zhO07yuZlJKqZAzpBDYBflLr9dbXx+bpuFI25tX/86v/60333iNMVRKdU1fnPFAAZEQkICapomjeDxcP5uenJycvPHGG3meD4fDEELVNsvlcu8qKqWyLOsK7Nq21fK8C50xFgiEVMB4WTfHp2e9wZCQtdaleS8ARkn69PkL51yWZd7749Ozs+nMEwzq5ubtO12HslJqMBi8+XbWZbelhNfeeDPLmNawWMBwCPM5aA1aAyI0DQgBsYLGQl1DHENZgnPgnEPgQqAQgAhE4ANkvT4BEPGiqp0nTxACeIIkgiSBm7duffLgAefgnBVCUAINQdtaaxxjTDHNOJCSgslJBasmLBpYHs3jOJVSlodw7xpcu3nVe1jOW0Kxub29nM+Pjw+VUoJ7pEDOxVGyMVpbTufgz3kcu/adqiydaTiFPI7e/cLndjc3m6Z5+Ojx05fHp/PCeCcFjAbbvXxUYBDIBQ9aMiRTV7Oqnjlb26Z2xgjOrfG29WQqT5WUEggRSUkutOzi0Ff3tvM0qZq2tdZar+MoiVMi2kr6/X6frOk6jsW1azcODg6McUpGH330UfCsY0Ro21YpDQBC8CzL4igVgsVxrPRSCsk5C8EF8oyB1lII8eTxI8654Bgrxbns94dp0re25UxGmnEmAMC0lnFQUoXg4iidzqZ5nnZ5m+3N7e3N7da2KHtZlkml0jzb2FjLeoO6bc5JpDkTTJHzUisRxcYFEPJv/tqvee/X19ffeffdjiChruudnYExUFWGc64U37txAxG1RiKwBqIIOIe6hqpyABAQy7axhY3j+Gxus0zX1mkjpssijmPRArzSjW+tdTYUjZRSEgMQ3IdgXQjm3NBm4Lwj44N3ZJxzNggd9QWvDUgDDODdL37+N3/znx8fn/WyyAd35pzWWsYKhTCNLavGOyLPKLDpdJmleRDZw4ePB/3RlSu7p4cT8Li9PcpiWBvrtfFdF+6+fHn68OOPTVs/XM3qaqWFzOKEbKiWZaPz5XLJhOJcOGNPjo6auhyPx6+/dudzb9zjANbauljVdet8mJVNMPVs4jHEReE0X/nAJDrBJUI7yKNYr2Vp3FEkITGuBCJj8bn0tkXZlEUIjnMZvM/SyLtWR6KrqsqyTEa6bdvJyayYh2BaWxdt24o4juM47fTjj3/8YaQTzmUIgTNZVSUiJkmS53nHdjAerXetxcjIGetCuAi+YJJkxjiUIhmkguu6sh0TTVOHoqjiOE5SDSA44wAciABQ66izpXq93mK5mi+mGxsbk+nEWNvr9ay1J5OzyXyW93rj8VgpJQSHAMdnZ6Y21rv9wyOl1PaNW91K2toYLBYNCGmpXlYQAgXGCbCtrXMujuNgYbUqEfm8pI5BNU3TJEHnwJR+MMilhNNTs6ha730KIu5laQpV5RljXPCub5IJrpQOIczLVWd1AevYxroGdWhLJ5SWnrggsr6sl2a2UHqUJGAcmCbcvH2XIX/w6OHXvvplch51vGpbKo2SOk6VCLCY02KxtCbMl5VQg/sPH/7X//X/Y+/Ktb/39/7eeHtc1pOzqXd9LiUgAAPY2Bhvrn+lbaoru5sf/uiDJ4+fNkU56g1TlbIAdd2qhIdgGIcsiXa2trSQrqmr1aJczL33DFyayPEgi7N0UTQQXBL3Jac8S8uqFSJoEQSn1Wpq2vLRwwenh4feetcGIM5RHB4+EqrLdrg0Tbd3d7a3dpI8u3pla5qoyWy2WKyms/nBQVtV1WQymZ4uO0Oli14J50LbtlXZBH925cqVPOvPZovFYrWx0eM177g+uy6vLtCldccP6Z03zhPnHYMgXfQu8bbxq1XpnEcAKbgUoPWgq8aSQiGA91SWdZYljDHvQ1FUaRqHEJwNkY6OP31alqWKdFmWtmkNo62trX4/v2C6tY8fPxFCCK4ePX12/fr1HIgraYxpHTApWmezfq+oa2ttHMdZKp1jzdI01iSJSvI0BEpTdA6KwtSmLmovpewPotPTZa/Xk9F5vscDGG9Wp22WJ8ae0/06HzAQY2iMSbL8wuDptJsliwAguXLEiqpobaCArQtJIvI+QADfAmMs0vG911/75je/+RNf/qK1BpNca2ERitIcHs3axguuI5n0+lKIXhTzujGroprMprPFsj+M65ULVLqQrI1EP+0gyDiwPO6vDz93dXf3T7717cOXh3ma52lPCdW0RsZp3dTL2fL4+Hg5m1vT2Grxw+9+azE529hYi9P+Rw8fny2qbLDWehq9dduvo7fu4ODgo48++uM//iZAYDxIDj60EEgI4dpQlY1gCoFvbMZdKHS2mDdNE8dx3u9pLSfzWdu24aIZV2jFGCuKQoSkC+ggkjFGWOPXxhvj8fiTTz4BwNOTCRFlWS/Lsl6PTSfzoiiklFpHUirOBTBL4ZLO6Dw71PHrbGxsJVHs2sYYF+kMAIrCxpFEBB/AeWKss7UxSTLGmDWewE+ns8VicevWjX6/P5ster3e8fHxfDoDCBsba0mSjMfDqlwJodq6KarqxcuX/f6w3x/O5otbQjoKUkoOVNSN1tqYdrSu5y/awWDgnGsdcA5xljIGAaF1ztqWydQYS4z6o8QYquu6dZD1MxVBQN46j4iMWJIrJhmXvG49IkRaMiG7PDsLzPqOshQQkXEhhQAAImgLozWXUc5k8I7mRTNfVmfTnmTAGeQZtDW8du+t3/6tf13VLUJwDdQ1VKVtGuucwCCBhANeV9Zbp2X8zjuf/8/+N//r0Wi0sZGdnq5ynTtip6er1Qr2doeDPjQNmXrhTDvuD7c2137lV37lx+9/cP/+g4ODgyu7V4u6GW/GrWuePn36b37rt09PT3e3N7/4+bdffvqwKlZrw9zb+vGD+09eHl25eTftDeezbeeClLptl8v52eH+M4CgpCDySgvJeJrmCJwjl1Ii8LOzs8FgEEVRGicdC4JtG+8tBq84Q8GNgeBbiUEqAYlSEDnn+nkMAFUF4qtf/eoHH3ywWCw4F6vVSmvtHQnBptOzsqwB4Iq4kiQp53y5XCIiF8I5VxSF90QgrG2EEAAsy7LFYhHriAi1iquqAoI0kYgQAiCCVkgAxgBREIIZ45Ikm0xOu8pWAJYk2XQ6FSLuyBhn06nWGsjPJqdS6CRJpJK0CoyxN99889rVm9/5zp/2hiOhJAF0KiAARUk8X4a83/MUkDPrg+1YZj2AB+RMi8h2jXMoWkvIMMmSDjqNIWDILlqXjSMmeF0D54oImvMWU0AExhkBIMMu/x4CXDJHcKFqA0TgPSvqFlByzibTdn2sIwWzOWyO4fU3P/eP//E/fvH84Nr1q5MjcA4oyNCiaRqtYxlxW1OSSNQSPcQSb17fC8FVRZ1EHEMUKKBMHNnD09WqwCxVaZx/9OmnSqgkUnHM3v3S57a3r9RV+6//5W/sXft6Ol0Y6+N8sFwu7969G0y9Nhr+xDv/Hnhz7dq1B48+fe3erb3rt1ClR5MzF2CxWIbgravzPM3S+OnTJ700k1JWqyrPexy9kkzJxFkXRcoH6ALXXT1LR/C/Khad35PGuq3LnZ2doiict1pJMpAkUV2XzjkppRiP19rWnJ6eleX5rtY0k4nt9/vOma7RtWmaqqqaxljrhUKEjteXEBkRMCY4o7quh4PRaDienJ4gYtOY7lZVFQgBXYgBsXvCAIBx0bYNEWZpDzDM5wtEMMY8eP6ptXZ9beScW60WxXIlpRR9fnVvb7EsFtPF+tparzeIomh7d2/QH63OmW4/e3Qv6ZyD6i8maqnbSQD05/5X68+SukRABARIBEJdvKSLz3c445/tDwHoAoJcAQbwDjwAgfLBhRCw9lkObQOmhYMjGI4279178w9+/1tf+vK7Pn6bMRbHTAshVAYEYAA9hgYAwWNg4BgnzoIUgIimZZ4YOWcp+OA511HEXOC3br+RRnpZuraoIhWvrY9/4a/84pUrV+bLJ8b6OOn1eoNf/5/8Rzvbm4vJyfog21gfVstZpPnVK1tf+fKX0uEGj7KXR6cJKR3HranWBqPRMFeSTU/PENlqWXoLxrjlcnl8cpL3FDA+W8zHa7GOol6v17ZtVekoUgCAwBFJKYXAvfe2bZ0xAMAYM956f87uxzgK7/1qtZrNZgBAREmSrK+vA0ASZ21rEflwOEzTVOtYiFpwxdAx5i6ILzgQF0Ig0Hi01oUZnfNxHL948eKHP8yKogCAOI455x2vN2PgnKvramNzbT6fV1UBEDrCP+tapZTqjUb9wfr6OIqiolgW5TKO49FotCwqORwgsUinWZIul8VgMOJcdjXXl8SZl08YA6J/BxCT9DPcnEOHAACs+3Pg6/YTgW3+4js7FLbt+c5ujtIldZhtXQjBB7LWF0XVkTAxwH/7jTNTFxy8bYtbN/YA9X/zf//viqKGuOqKDsfDUZpmScJlAoMUCAAZIDACFcj5YKzzgZyQMWeAEEHQFNpV2dRlJbi7eW0LBUgmQpwGAhKwfXVzMB6cHG8+ePDg+MVLeHmwtrZWVVXwnrw1TRUpkWi9X+x/59vvFY7i3sgSw9oPR/1BL79+dUdpubGxcfPajUhnWqSIMk1665vrT548jhO5qpfHx4e/97v/gjE2HI1Xq5WK9O7uLhFxzj/55P5oNHLOlWXJmZRCdxyKaSyFEM7bDhjixx98tFwUXbS5rmuikCSxtc5508mntm2TJO38g6Zpkizu6nMoEDCGgF0DXJZlh4eHbdsyhlLKTz65v5zPjDGMQ5qeD8DQWo9Gw47uLo73GGNbWxtdvae1bUfvV7nAkXU9jgy2rbMEQQi9u8kIWMdi3gY4mzRVY+q6OZqez116laGViLoCdHiFV6n7u1gs6N+1XXb3XX6ke39bycuDhxC66VhwTvKAF+xMcMkFrbWmLhDoqGnM+RwH55VELZnQsqxmxcpc3bvz0Qf3J5MiHdWmaRezxYE6yLJeFEVppPNetrExUhKiGHQESgoKqXW197gsSTLkAjhDBoJhFNAHcvuHq/W1fL0PUnJroagMETEFWzt7ljA5nRwcHLgAi+lscvRieoSv/bVfqleztmmEEGkaK1A1QVvVLPiqYWkmG1cX5WI+XdSRcXYpWbz/8lTp5Ktf/cmXh6dSgYqBS/bFL34REV9//fXT09O6rnd3d6fTqRDi5Yv93d29xWKxWpWMMQDBGFNK1a0JCL67I4jiyZMnIQStYmRkrbHWrlar09PTfn+wmK+IcGtzNRgMu169jviQMWAoAl5MKwKOSIvFQkqZ5alpasCgVLy5td7v93d2NtM0vcTfeG0oBAsB2J+vYWLnPL5BC8EArLMcATkqIXzwwRkhVABmjeeKawaDfnR6Mv3d3//Dpbj6KowuaSE7ftxL2F0W6Aou/6JK7vZfDB677Bw9PzGMAIghBQKEcK6AiSEgEDFARGKc+Pm0CqrO+UxYCBRAIksA0fnKe4qiBAGUyE/OFkqmG+tXfvTD+3/pr/+kEGq1LKfzompqwTgAS5Lo5cs4ikTeiwfDtN9L00zqKJaKYdR53OAcBA8CmZKChC7KCqEmivs9EBJ0rhCAMyhn4c23Xrta0Xe/+90XL55xZPDKxLUQXBxHnHPjfF3XbWuBrJnX1lV5Lxr2B5ubW5rl81kjMWesti0rqtA2YbacqQQn08Mfvf/twWDQH427+Sin09mjR4+Lomisi9PebFEE4M4F78BDoOA8BCJwIXDOhJIiTXNr7eHhoVR8Y2Oj3+/neR5FUV3XXWCFcegKLbs8B0OBQABIAQnx0gVmjOV53tXCbG5ufukLn3/zjTeiSCl9Tov+6uacCQGklIyh9wERL+mzqtoiBMYAOFLoyA6QMwkADEAr3onAWEEIsFisxLgPCMg+E0vnTwj/3FdeKmjCy1aByw0AOqZsuGDd/EwWoryENgTAcx5O3tTNBbw/wysRaaUAIAB6RwCetHMWHYayWCpunKAozsm3aabuvf7OH/zu7zx+8cnu7h7TDJ2XkRBCudYGwsligUuQU6YPeZLKvBdneRorOdjckRKUBKYBgwgeyENrvBTJvCjKpl5vs61NJRgggAfoDeIAwDjeuHnr6OjoeP/w7ORsdGNbKZWMRqONtaSsAKAoikVRo4xGwyxJIqRQVQX5YOsQSwsuniznsR5qHZeFkSoRUOW96Pn+wyt71zY2NrZ3rnQXbTwej9c2zs7O/off/h2t0rbxpg3OuQ4n1ntSgRF4BKlUlKUiiqI4Tr33w6y/t7fXUYqvra09ePCgNTUFfl7lVpu2tcYYRAZw3mZCQCF0j5CmaTcb6O7d21/72le+9IW3OkgEct3kj0uBAgCX8xq6zXtv7TnFYC/PAAEIoKuJ7NxLBB+IC3ExXwJaC23brg1Hp0b8BTB1R75ky7z83+6Jd+fMSJcOS/dS8r94hE5kGtMAdAzMjIguB3soeSFfw2fgA4DK1QDovXcuUMAQmPPY2hAnOSJHBpxjCNTUZZ4NpYwfPflobXMw6I9b1xIzLmBtjUeWp5n33jpjS1tU9WS6EJIzxtiD51mWrY3WRqNRL1VRDEKCYNw5ANTON4tVyXXo5xHj3vkm4unJ1AyH6urVtTj++e999z1TLoqiqqpqOT2Zzyb5cLSxsTHevfp0/3he1C8Pn966cV1y0ZiGMeEMDLJ4d+/exx+9SKKhIzg6mo7WoiTJvvzlL9y4vbM+HvT7/TTNiIJzTsro9r3Xjw8O/s1v/66OYuu8s+Rcx1kPAFBWK7jIJznnRdfBGkVRxwj7/e9///BoXwothGjbVoq4a2+LoqjX643HY0TsGtuIKFwaQCFUVVVV1bWre1//+te/+MW3EKBYtVmmGYPW1G1ju/qLtm2JsMvvGWMQedft0ZHHcyYRuBRMCCY4AiMA6lQ156KtG64iG4BJkAw6GkzB4s+wTQB0XoccLsQhXrAIIyIBMOSfiUk6F4xEEC5mKV6C71xxw/k0H4BzilggBoDnlXCEl+ZiN22LOq7cwAMAci4YSKmFUFWx8oLpYWKNF4yFAIPB8J23P//7P/y3d167k2SZpZZ7qaTSsU7TvG0sY0yomCMAeiLvyVnrMDR1XZ+enkmu0jQdD4Zr42E/T/o9HqcxBV41Z+Xz6XKoNrdGuUwDgNaKI7QWer3sl37pF+9c3fret78RRZEYjQb9XERxWZaLdnF6eupRxHHEpayqAryLVGItHR+f+jptasvRSR0LodJe78mLp2V9XmuTZVnT1AAQPEhBAFCVNWNMCOU9GWeDIynPO9S6uU7OORXpKInFaJjVbbO20T+bH99//EFRrHavX+n1ssFgdLh/YFov45BkGMWuqk6QVt5lUjAtuWkqjjzRcYlstlwkSvm2/ZmvffXdL36eAJ7tHzOGi5oLuCBD9kHwKE17ROicU4o1VQ0AZVlqLUOQzoXx5vjJg/vvvPsuIHiCpvVSSckAISzmU8nkYlUkvTWScLiAko32qyjPCgBGXSKABAGHVxCGSAwDMoNICIRIFMSf08dwqbg/092XWCYiF/wlvBgKQgzkfSDqUu6s+xR5IABPRPx8HhMJ5ruiVImmFxPzMJ9PEdrxeOQCgRotTMi27mbf/p1n3/nTL125LUhAYCzwojSlbxAZcmIsBBYYJwTPgRgCBG6tJQLHwrwuTg9nQsgoitI0WVsbbW1v9Ps7UkHZwsExaA1XRpCk4AG8a5MINfrX3trtD37aCywdM20YpInj2Wo1y6JxsaoUhO0oPZgufNl4VoeKSPAQzbY3eqvV0WJejtf7Tx59+OjxBxvrNoq5HG3XIbx2+5azdRKpupnrKOO95KCoTJwVGJdBRgJda1LBnKl5xtqqllLwts2QxOHhYeeBGtP0817Hmdo05sMPP3TWJ1F6PsYSwDk3W6yu9sddGp5z3rZ2MV95H+I4ns1mP/MzP/Orv/orAPD02X6e510jTzckcrFYzGbz1WpVVU2xXJVlfXR01DEiLJfLK1d21tbWoih666231jPdVo1OI0SQknduQ13XnPO2aaMoEQL++NuPfvsPv+N4MhqNrQHq9DWwiyefaUMACkiMsGvlYeeS7Bx2iHgZUsGLMaEXwq97D12MHgJAFi5qjT7zaS7I2RmAv/zu/z9bN1Kqu3Tdx+M4XttYX8xXjx49unrz3mReRzLoSAKycHEanVPFOpYtICm7kVUA1BHPn3cJFcVqNps8f/FUSkzSeLzW39nZGo9VmwBo0AKE0sZaYkFztbd307l2Nn2Y5clotNm2VnD10Ucfta0V7PQnf+KrX/qJq03ZmtK/XB5UxWlTldeu3NjZ2P700/nBs08fPPqBx8XZy9F0drrz2hexrca5XhvkABAJbMp5vZxe3V6bnx4OUu3Xh7mWCcPJ0f6N61ceL44YSYEAZIGc2Nnc3trefPzkybPDZ61rmcCqqpq2jaIoipIkyULohlG5oiiOjo62tna01sG7bhCXlJLzYK3d3Nz8O3/n1xcL84ff+MOP7v/Ye7dcLheLRTc/t6N6YIwJLoHItM54U62aEMLN127fun3j6adPjqcnP//Lv5CFbqYNIAPOIXT5Lg5aJaADU/FsFR48eHBwcLCxd5sxAefcW9i9EzCcY5EIkQgCEHgKDAOeD9y7ULpwznJ1KQYRkeC8lu1c+gF1UxUCBTznNoRLVQsQ4BXIfoblDpqvvOy0fxzHwbm6rjvfnIjSNL19++77P/jR/Qef3Lz7JnSTm4W23hMhBiSgAMAoBBYYEUBXOcE7AmIAlFKGQM65jmeiKFrnDJz5oyP59OnTJIk+GeAbb9597U4/UhBIMi4RwVODyN56892jw+MPfvThteu33//+j4b90e/83u/fe23NhJD3e94VwRBnuiwOj1dn5fLF9trtYm6zXCfY9EfRRg67o51PT/ft8rQ6e3nv1vVEq9H6mg9soOE/+1/+z6I4C38ZivmiH2vh3f/nX/y/N8aj1f1Say0QppNTX8/F6cmJVmp6dtaU7ebOxubO5tr6ehRFy2LVttbbMByM+r1h1p/n/UF/OPDeGoNpmpZFJaRaXxvv7+/Xdf1rv/ZrSZ79o//r/+Xly+d1U56envT7/TjRIkkRUQJ0xVG93kBr3YHl5OTk9PT02t3rO1f3nu2/YE6++fYbfrKQkfIXAZpOxmilAahjeuxoAAaDwXAwrhqDvIuEM4TORAMACBgIujEcl1IQIZzPP+9AeK6gL6DIkL2aDrnAD3ryIWA3+xTDuZi8mFiBGIg+E7l/QfRekBkj4sU8gVVdt23TBeSJSAhx7frNg8PT1ao8nUzjuGeDYyitdVyqTsaGQICAFzZt29Zax4jovQ/BX0wl4dZazlEKqbUMwfngFvPVbDYrz+Dho4NP7l3/S1//3NY6eA+TwiZKTM8mV/d2t7avrq9dmc3qN/7O5/6P/4f//N6du8Cb6WK5ZVrriGHsnDft0pgXO5vrwyR8/d2fPdh/3sxTrqdHj36Qpf29a18oV8v9T34s6tlqdra5vWVciPOBJ9FaYoyXi4UkGma6mrzMt9K/8vWvbGysS8Huf/hBU5XCtq5cFba1sdYC5dnx2enJhEuR9fLjo9O6bvZ2ryZJb7FYLcvCuJBl2Ww2Gw6HZVE1xhL4oiiuXNn5ya/95D/5J//kj/7oD27dutVac/X6tWvX9qSUTQRdp0mX3MMIgQcfwv3799dG46u3rt1+/c7a2trt+d1nz55VZPtRxzHqMDChmPeeI1BwHLGtmijrCyFCgNPTiUyncT4khhTY5d2nznE+x1yHkc/+o2PruYQLIr4iwM4FFXym+AAAAvFAgQjOvWUkArpUxB3NzZ9D2/+P/MOLEY3hfEahsdZ24cYQQpoPrt+883L/8PHjx+9+8SehDY48soDkujg2EnaRrvM68wBdtCuEUNc1EXY8YFEUEXnvrXPn3ZBSakTlHFrb/tn3Hx3sn33tK5//8hfGWSoPDuZ7O7vHx4s40VqqPO9/499+6+///b//4Yf3v/GdP7KB0jxTTDZTLIvW+uVw7D/++Bu3d8Nbf+s/ffij9yXVt6+OJ9NDX83sYurKZTs7pWE0efmEqllR1r3ROnHJdTLoj964sX388tnhp483+/Lt21f01et8YwMg6FA60wjFhWud5GI8HGdJtmrKQOQ9VaumKEprPecyy7K818vSXpIkjLFu9lqWZe1sOp/PB4PBz/+VX/z4449/7/d+bzAa2mB6vd7du3cfffpwb2/vdLbsrnsIQUtuXMs5D87LSM6Ked1WJ2eHB0cvptOzJFEKeV2XMtbYDZSHLlrhm7oC8gJkVTWTSckY29jY7PcHNnCibhYr6ww1jhdcEBcwC+f4YAAB6DP4vertviq0/oIAc4TUSR8KDBm/TLQE6kI3cNkOHJCIgH92EHoFgl08gXPuHLZt2w1T9d4T4xub2z6w/cOjsix1lAbntURPHeMAdTQX5zEvCOdzSYF3M7/LsiIipRQREXkiAgyMAScUQjDOGwNbG9eMWX369Nlq+Sd19cXbN3asYR8/OL51c7NYVhT8W2+/cWX36j/8h//w9u3bP/UzPw8wbdu2rYNgA8aEkD7JPAtNWU0hTZvGEFFZLWbzs0SNzGru65L7VnibCRrGohf31rZGs0U1L6ZO0N23fna7r/6HT3+8WM4f/Pj7b2+OYR7AtNCuNkd9xpE1TWMbW5bl0dHRfDq3jVktVk1jJFdaxURkzXkLyHK5bJpmMBgsl0uC8xnBb739xvXr1//ZP/tnXLLbt28D4u7ebm/Q71qT8HwciFBKCMFCcG1TltVSae5MnaR6a3ONgkvSaGN9DOC7uIZU50FrxlgIrq7Luq5b05ycnEwm09Fw7c7te+PROgAC48BejW8HQAfokHlk/lJsAAAhI2SvRvg+M/5emfH06pO/sBO7GwyhG7hL5wOpulgUQrgUin8Oza9CvBuT3g3tEUIQkSXgMhqtrQupP336BBEIPGOBo+fokfnLuckA0E2odTaEEPI8X1tby/O0mzx1cPByMpmUZWmt7RKkQigl47y3cXI6t16+8eYXddL/17/5u//iN357Vdl7b2yezdq8n2Q9WbVeRfJ/97//3wZyr999TTCxWq1mswUR6jjRsUJh+2uZjCOYzvPRRj5axzjtb1zZvHb7ys7O+mjci1PftuAdOhdzpsjv7W4kktWreX38oljOenk8Gvacbx5+/MODjz84ffpoevxieXYgQghKiCzLPFBjTSxFludns2mSZEmShRAinTDGkjju0miCwZUbN9577z3viQFGaXL9+vXT0+M//d53oygq6woAHj958nz/eZpn3/vB94xinHPGASkwxhhQ01RNXfZ6PQhURvLHP3j/4cOHP/nlr9y7c0cA+ou7ZYxjklnXets2TcOQTiYn85XJBju9Xu/Dxw9qv0x76/Z87hggEANPQEif2XmEgUHHzXyZIfHw55F3AZNAr74EugzBsG7CESPAC8WKnog4IBFDxK7xHy6SIf9OCHYojeMYEebzeecFExEy6byNk6zX67148ezevXvOtZxzxkSgwAgJEIlfyFkMnrp67zRNh8Mh53yxWDDGkiTq7Jy6ahbzFePQEZylkYzTPjB3cHzC0W/s7DWm/Y3f/r3tnb8FXC7L0BjUkquYF7X/j/6nf/u//e9+M9iwNlqTRBI1MAQpSUQ8Su9c/4KPMtYbmao/uLLVB392UrKiXRVVa11V1gDMe4/OFUVhylrH0c5ofbaYf/Tx/eWqNHXpvClPDre2tnpZenz48mT/CbOuzXrpYjFbrVYhhNFolKb5G2+81c97q2V57eqNz3/uc1maaiGDM6apOOfONJubm6vVKo7jfj9//c03/+k//achhLuv3ZvNJl3h66oojk+PkixlAV3TLiezYGxbloM8a8qCU+Dep1pFiLevXr2yseWaul6szj3UAIwBY4whYwzqug7kuhFLh4eHDx8+BGDdHO+uAgAAvDVIPtKKM3K2BrIMvTUVZ5SliZYc6XzGDgtWc3BN6dtKgCfboDcSAyenGKE34FrNIY+VYuTbSjGSAoQIbVNqxRWn2eRQS1QCnG0pGM4gBI+MtFKiU6l0PrP9Usp2FLFaawDQWnfcst3ERusw740A5elkiogff/zjPNVJJAhs8Ma7lsgjI8YEETjnu2mgiPjDH/5Qa725udlpjM7ETJJkMBisra2NhhtapdbQ6dnJ0cnhYrUELoCLZdUsytoD/+affH+4zvojZjzICIADIRCDX/7FX75357VHD58656pqleapigci2d679cWXZ5XVqhQyZOufHNUvV2wK2XzVqLiX9sYgdCDe2FAbVxkPKIqqWVb1R588LlobpHaMFybcvXt3MBjMZrPJZOKcE7/wV37h6dOnNvjZbHL7zr1nz57dun335s2b/+pf/Ya1tiyKs+OTfr/PESIlIyUBwBgjkMWxbk3z7t0vfu9733ux/3I0GmmtA+aT+bRuSwBw5DY3N1Odai2LYulMszYaZjq+c/XqvdfucmQPP3mQR9H+s6f9OD7dP/y5n/yaAqQoepVexXtfVcViMbOtOTk5WyyWIEimLkmyeekaU7aMEfm2qRhRGksMHiFoHtu6sq1ZzWfEOJcxCoFMCKGsmUdRpJRomqZtG0RcLouuPCJJko6k27moG2o3HA7n83kURbapGLnZ2YpzPhpms+mx5Mp7L7j21rWNJwIhFBERd+fCjzxdzuH2jjHmvQc67+VrmqYLozKmrAeu1Obm5unpcd7L6qZI05Rj4AJdOB9xE7z3DjxQpDgiVlXVUZPfvHlzOOpPJhOt4gtxzhgDxs7ziVXZAAai4L0lToDckzDB/uj+w7uv3bt3N40y9AAIYIl5gPFQfPHdr/R6vaZ0SubD9c9PFsmqemFRbd+8w3qw99brW7SZjbAslyen8/XZydnp0fzkCH3TVlU26COTq7otFxUI3eMq7aUmMKVTF5Ah/fDH9xEojXVrQ9lY8cff/mMASPO0Px70hr3v/NmfLlflzt4VY0wvzSTjVbFaHw4EAxZ8U6wAgnOuY9qKIn3jxo3/23/1TyaTyd61q7Wpq6oihM3tbUSaLebWm7fuvaG1CsGVxfzW7euL2WQxl2uDkTNNMK1gffQhi+KnD58M8h45f5n7R0YE3lpTlqvVanXn1u0s7l29Eb08Ws7Ldj5bHs+afLC5bGeMA3ivJCoudawiJQb9fLlcUh4fHp8uV8s4ZwygtrVWMZVnYKIuDnxOm9Q0JCUHsGXrrEVEF5q6KIgoxNzVbW2KslylWVwsFy743d3d1fxUCiWlJkUIwgeggCF0ou4iNP2K+QgAHXsYZ8x719HFdpH5KIqsc1KIrZ0r8/kZ51gWSyWRgiMQHAWhYICEKARnyBgL1noiiqLo7Oxsc2t9d3f37OyMcQBiRMQYAiA7d4tV160SgjMOJCIgD0wET9PZ4v0PHwa4tz6O+zlIDkyhBygrGA4Hb77+pVWxAPAnp0d/9qPpN771/Z//hV+5fef1MgAmGGzcgq6RKPJn5dOz5SrKh3s745P9Z6umNqsCpWI6QRC1Z+P+ejtdtaZ98OyYgpucPjWm+dzbbwYHB2dLsXNlWyo1/+EHe9eu9Xr9N9966+HDh88+fXJ8sL9KEmfa8XB48+qeQNCcoXfeeyk557yqqnfe+XxRrH74wx/qSGotOeezxUxG+tatW8ih18sAYJRt7R+8GAxGSaw3N7eK5bxrCCdv27ZNo/i1u/eOj085YwxFCKGuW6U1KoaInnxnqjtn/+x7f/rJh4+4ystGr+++vrGxUdq5tV7pSHHhXYvelMVi0ZbBmyyOrl+/HqWZaWtrbR5HJmDTBGS0sz1ijD158qTf70cRTiaT8XjcgX65XOZporVeLpf9XEVRtFyeDtKxtZYUSTBrw8QYUy5PEw1JpgWPrPPWBCEUgupKwYldFrJ2lTLIut6TC+uwU5Sd0jTGcKmQMetdr9fLB/3p9GxzY7xYTjfWt7wP1jFwEJBx0EAiAAOqnXNRFJdlGcfxy5cvP//5z4/H47ZtvTunJaUAnnwIQMTjSADZpvHOUcdVhsQ88Xyw9fjTo+Wy3dkcb6wPtzbGgx4whIEAYJD1VDZcB7DZSL88+HJV7dy8+qXt7Ru1r9swH27stCbkuWxMfTRbOuD37r7+k++++f6ffuuH7/9ZWTfbexug9LK282W9y6JlYQ/3T+8/ej4c9KJk0NBytH0jOHt8+FJ89/3vXr92I2BwZA+ODh58+mAym2mtb9y4MZ/OZpNTTkEiCIA8SyE425o0TbMs01q/9dYb//Yb3zo9Pd27dhUABoPBi/0XnGMAMnXzS3/1r+zs7HzjD/7s06fPr1zZ8bb55MGDydnp5vr6arlAEKO18Wh9Le/3iqLKe70kSQCwaZrMewGMIWtMVVarpu2GK8H6+ni0fvX5fnFycnI0J2uj3rC/ag1DCBCCN861TV2Aaw0LxWrOGQRvBHoKlgJTUgzy3q/9j17zHn73d+mtt95KkuT73//+66+/bow5Ozubz5Nu5w9/+MOdnZ2rV7f+7M9+NB5dyfM0hPDJo0+uXbs6Xh9958++F8XJ5uZ2WdpHnz5/uX/CgQEXzpEQjM6jj4DwWdUqEkkpOzXahUs606KuaxnnqVZVbYTEjY2NRw8+3N4eL+ez1+/drWpbFqYNBMQCoXPeOCd46MiiiHyWJ/P5fD6fX7ly5cmTJ45cCNRp3hDIuQDkYu05ICKSD8GzIBQyRLBKy9lsulieTs7KPDvd2hitj8fI6OooETz1zow27OZGmC2PBR99/o0vNiv7/vc/hujx2ezgF3/x18Ewj/7Fpw+Cdca6Fwf7kpmHDx+vyppLxoSI0nxezRxwGaceeOvh6s07v/CXf37vxvrJyckXPvfO6fHhH/7B74ski/eP9p31rWtfe/P1Dz++L6Ws6/KnfuqnHt7/6OjgECEE7yC4zfGorssQAmOs1+vduHENEd977z0pZa/X66YXRmkCELy3x6cnZ2dneZ433nvAtc0t7+vZ7JQEu37nlmka9O7Z06dCyUeffhpFyWhtHGdZXVX4Svmdc64rq3G24ZzPZrPDk9VkTiq7onXGdD6dTnkUBQjgHYOghEj7WZ6ubayP67q2bYXeSM7JW/IsUnEvz3oZEMFoEO/tDvIcDl72tzb6dV0fvHysZbiyk2sNH8sw6Okb1+DkaD2YcPeGBg4PPq7yRLz1Gnz6OCNkP/1Tg5NTKIrq4OA4BAdgnSMmPhvEc+n24kXWji5GfXeV6J27aqxPU8659M4Mh0MhWdvWzpumrazxgboxFp1m55wH75ssS4+Pj8fjYdu2URQ9f/70jTfeiOPY2dJayxjnXCJC8ITInWkYoha6td57QMe4VIiqaRwXAy2ZcXB0XE7OmjybSSln20rhWEsBEUSD1ZP9xw8fiRzuShH7dnXnc0orOYoh8nmWDz6O6AQ85/jxxx8//PD7sYY3X7srtUKpV40vy1olZrFYLVZ1VZubt+7+0q/8dUj5zmTS39rob187W9RivDFWKmobu1jM/uTb733yySe7u1f6/f5selaWJZBvynYxnQH5na3NxWwWxXFdVoyxe/fuvffee8+fP9/Z2V5bW5suF87Ze/funU5OkLP5fP57f/gHrx+9/uL5UsbJ2vYmBduYsm6K08mEIxSrRdU2h6cnWupRn+6+8SYBeoQuT3UZwuhIiZ21q8WSc06GjDHHL17ManXt9uejKEGBXKDzZK1p2rbxTbBCS1JKLRcrZzGJIkdofeACg7OruUPE8SC1TV1j3M90Wy2QKNEMkZu6cS2LFYJvigVI5mtjfLtGDLSgppwvFr0slWVtjg5gVUHdFM5ZKSNgDMAzxggu4jv0Wd0hXAzt5pyHAOFiYi4A1HUTR0oqGUyjtdjbu3JycjQeDY6ODgSPuIg5F+SRCDjnXEambdvWRFHU+SVpmhbF8vj4eDgcWuPb1gYPnJ1XJxCRM1bqSCnhyRlL4f/b138HWZad94Hgd9z1z6U3lZXlu7q6uqsd2sARBEB4R0A0MhQpUprYkRnKrMDhrFarGY1idyOkkWY4VGi0IjkzDBpRIkiCAg1I2G4AbdC+u7q6fFZ68/z1x+0f591TN7PAuVFR8fLlzXuP+X3eHK2YRpg6ZQmBFzLGpCg0wlmZ8wFnRI9GGwHLRVFu9rr3jYvefj9LVwLsFgW0l9zTq9M3btx+5blvzU89MnNuqenIF27f7jTC/f1d4PHq4qxRrF3HXViY2+uPKWHxODU9Dlw/TJIsiDqKuL3dvuR8f5jS7e3t4ydWd/d38pxvb+0uLC3OzMwgZMo+gsB14sGAi4ICBJ6zX+bTYRjHMefFytLSr/7q/14UxdLS0vTMjADdbDYff/KJ7z3/3XE82t/fjbP45MmTL7/+GqNkc3sXQbnf665vru8fbDsMd/d25+fmHOJcevBSlheXLl2SoDw/lCOhlCKATYITxhhAm9TUNE03t/r9EcpVsxSAMU6SBFEU+i5CwByCJFGAQEspxdbWfr8/cLzm9NwywgRAg1RJkrz60veVUnEc37p+TWudpqmUMggCU+a3vbGutR6Pxxtrt9941d/d3Q296Y3121KrjY07G1vrV65dGY5GudCbWzte0F5f30mSpN0JTb91I1Ur+Xu3HgWUVEqZTEopxaSTMcaU0jzPxzGenW1Jrbkol5eX37ny+sL8TJaljYbjeR6AFye6LEvQQBh2HKfb7S4vL+3v74aRL6VkjG1sbDz66OPjUTIcjqWUGEslkQE6wdpDmFCv4LlSXGuNCUKYYOQozcbjTJRF4Dm+52khNKiMy1ajKVU6TjcmvSGdIB8AQSCKMov7O5vXX3/h1R/5oYViMczH3XPnzh5fmj99fMFBZeQi18Fa60uPv2vmzPnm9CtAvOnZxTNnzuxsbRGEOedxzgGxXKRLi8eefOo9NJpaUDjcH6QUs7n5Y2u3bp870zp95mQax99buz7o73supYFSiu8lWwO+52Zpu92ei0KB9NT8dPfl57nKP/bxH/md3/3PUsq123d4CUWGXW9mqjN/YvWh9zwlXn/99SwZa6kOtpPlzn0uYy5zkh0n3oWZdgslwQff/cRCZx5AxcPBgTwIvUiDliC55N1ud2tnP2qGidD7ed4vcuH42Wi8v7N/auX0nBsd6PsBUyWTQvaRyniZDkdi0POhbPFCzcwuki6mKPNpqbNkuRHd7sRlLqPpTm836W4MkWjKXHqlxwuhIcQp0YgpPL8zdPSAKbTsC7y+p5VSHKJyWMqe1NoFgDv7GqEhIVHYbAqFtNSY0izLXO+u/NVaTZzYCLDpFMOFSVwBSjEAozRJRoVUpaDMd8q8FJw8dPHpN19/7b777p+bnsfgj8Y5Ii6jOE5LojQg6YeN/nDEPL8UiiBuClCu33j71KlTu3vrzHEoFWUhyrJoNptS6HGROLJwGIAu8zyHosew77tuPE4pYWEjFLIsuMaYcqmYXLwt8gK6n2qfXLyyF0413ig29NKLzUI30XDn9YKKc3MLMWW4MTfzrg//jeNT0yLPqetBUQIX4HmQlRAEgOCR95wBrQUo4pATD4EE4ACRhhzzqWkGANML03Tj1o5aIFCQOM2USo7NnXz4wrsip3P52pUiVj5pqEIUY0kJdgMvZJ3A9TzmEEL8KAyCYG5mVkp548aNVqtVclkURavVanemkzwjhF2/fn00HPie5zBSlCL0A9/3+93u8KDXakanTqw++tCDF86fXVyYA9BScHk3IUpJKfM0G4/HvV4vTsdra+ujOBdCKqQwZp7nmYiq1+whArwcSj1mLnaoQI4kSGgFAXK20/WGF2koyny8tDzdY2Xc1WWuM8hU5rh4Ji1LUXAsGQBBSKu7CTEKkERaKkX1JOarbFAEIWTOnzapgZWzRWutpdRwT0DvaBzvcAxQCSFKSV1CCDH1hGHYKMuyLAtCPYxBSCmkwKAYo2ryOomU1loJEFpLAIghzrPi7Nmzb7zxFiEsCpsAWAhBbRwTY0LkJO8BdNW4jEgplVSUOowxVGqs5cL87N5BvLa2dryNSUpPnTrxxmbqCuy1fMeRq/Oru/tXZ2Zn80zNz8z29/d6vV6R5aP+YGF+/sS5+yGiIARgAhQBQgQRDsA1lEoCwPXbm0aaxXFcFAU9f/xCp9PZurat03JhdnFrY/s//h//+fixYwd7u5IX0522w1xXB7Lk/WG8dnOjuXym2Qh9z3cI3li7MxgMrlx+Wwo9isfN9pTr+44XTM/OeMw5duzYyRMn3nn7pfvPnH3w/P2vvvzq5sadrDWan124dP/9K8tLp04cP3P6pElv5qIQZWlCogoUBmz9tFmWZVmyu7urEQNwsQZCSBR57XazLPQA7YBSCjLClOu7UkEBvAClEVM4lx4kQSZBFlxzOaZp1k40AT/JdOBGEYu4jgEJpbQGDojjCbykQhqAaw2COwY6SgqthMmqQYCQ9akohUyZsdagtRIaDsd8dZUPMUlkMBmNproXYQAwha0O8wlmCCSlztTUVBzHw+EQEwcAacFFqQAwxcC5rKXFCq0NYUCSJNvb2/efP+8ypyxFkee8lFLKIHS0lkIIRohSwqRkc84JYcwhjLpCKCm1wzClUBYcFE9GQ12KKGicPbt8+cbbjWNLYViMN3bDkwtzc8FutocQdl13e3sbtUAOk+E4mZmZOXXuPsdxxtlYKWi2GgqgFLpQohS8Oxxs7e4MhiMp5fHOAmOs2+2ORqNGo0Epxv1u98GLFxtR6/q1axTjRqNxsLd/5uQpXuauQ+N4zLlECC0sLM7Nza8fdGc6U62ooTEaDfutqNFutxmlP/1Tf5067veef0Fq9cTj75qZmSkLkY/HTOsyTW68c6W7u3t6deWhBx48sbq6unL8+NI8GLe74GWZItNLH5uzdErA3qRcwPHDsMF5cePGjayQnBOEwqJ0s9xbmDvp+U0VEswcFzNMXIq9kueF4Bojv8FGyXBqbjYpSk2x15ne2T+ISDMaZFGrJXKhOdIeYzrEDHFeSJ0jDEoLpIWucpkxgJioc6CU1Foa5ocQmB7wpobJIMD8r6roc2V5gEGcLXg3vwMNmCBAiGEqBM/z0vccx2WgNaWsMzVz8/qNg4MDhFkQRAhjhBUoKWRWpRtqhDTBxLQDAYCiUDvb23Ozs2fPno2H8WAwcghQSjXmWlMAYIRg7DJWmlw4pQTGNEnHe3t741EyOzs7NzdHMfguPRiNKMPzs7MznRktZJ7GU1OzC3MLD16YaS3L737pBc8Pm522Ymo32+m02qfOnDOiIZXCaTQ0wAhAgr61eXttfT3JM4QQc5ypmanZ2dljncVer3d7Z3tvNOQE03A6bIbRm29eXtu5/eDFh85dOP3WW29t3Fkf8VFepDrl25sbyikH3e7qiZWTJ1fDziwBLXixv7+/sXZHY5Sn7sHu3v/8b/7N0+9+71tvX+4PR47jvH35Ha31U+9597B74AAw0OfPnnzowYfP33cfwcw3J64oXZa5lpxS4jAqRFkUnACSUgIG01jV87x2u52m8dLS0vZudxwXDnOlokqUhKLZuZntfspwRMHRylUZEbnjITdoOVzHoUviwZZQ0vFCSvBCsw2atHBvyuUN4vQHcTIoFPIRogXPiYsBU8AKG8akFdISACQoNCmoA5PfagK7VQoqaK0QMq7mKgXhUB2J1QUPpWNBVaFHMQOsRSnLrPQZJQgTzKKoQRgdxWPmuq7rOm6okBBcSZESGpjnAQIMCICYDMfZqek4jtdu3rp48aF0lBR5ihHN04Q4ygyJY0wI01qbMsVm1BBC9A72r71zpdvtnjx5shF5rVYrQix3MWW0SIpbN24z5vb7fWd+/vHHVloh5P3NrZ39Zvt4oxGgADAsNCFSAKWUCiNEaAGwOTi4evPmzv4eV9LzvM7MtDk33g1D5geYwc2NjdtbW4PBgAYB3Y0Prm/f8ju+F8LXX/ym7/tnz5w5dn7lxRdfzNOEUdJYmXr3R98HAMvLi6vHjjPtGQ1pLU4Yxa4XaK339/f9KNzZ2r5ze+2g23vkoUuh6wzj8cHO9oUzZx544IEHH3xwcWHZY25elEoUiAVxOqKUUqwVIKVlKaSUUoHEGJRSpqqMc44BGCZSSs9xkdJKSOxihHRZFnmeSV5i5BHwNbiqpFIiwst2Kzq2EFGXTs20Nrauz85OtxpTZYFmplburG2TvUTjjcbcMdDjO5uxG87lkmkkMPMAKYQAECZaIUAIKChNKEx4njKJrchUCQtxJM5WSVatqzRsdAR25jPGGEDZdBzGGMWoKPMsLQLPRRRphF3mTE/P9Pv9LMuk4oAEI4C0KgtBCNKTqjsEoDVIJDWA7vd7DmODXr/I0kYYLD/6yMzMTBynhUyrUlSTFIGFEEXBr199h1LaarWWlxZdh7RbkUs1yFxq3h9nlCG2OJUMh3mabw32l+bP7e8rcjDY2Xn77LmLUgfYgSTNWYCQhiQrBGgv8LpZ8qff/mbCi+mFuamVZUOl4zjZ3j/wmHP29JnZRqsAuHz1+tbewfb2dn+c0BMPPLS5udntdiVFjaWltbW1teeeO3fm7PlHH9nf39/e3NjsdzcGozAMIq4OinKOlwoQImTj9m3JhWYKY62lioejTbx54vhqs9ks8mxxYf6xpUceeOCB8ycXW62Wy1wjxAiSWotBfy+KIkyQUpqXpRDmXGCrwk9knhLCKCvpODWH3iilyiLjnCCsAak8TyVCEgEBRYmDpcI6jpCcYmlZXC+3t0+GuZPJDuk0vZm9d57zd0edFffazc2Fhac6TbG+vY+ozguNvYbUpQYw4QutFNEYS1PrwVHF2UzHNYQxgDk7cVIdZESroRk86a5Ztz201poQYu7BGswp3+YfI5Q4TJRlnuech4xQrRAAnpmeM71j8jwzOCeEABKCFxPzCACDMpIdAYRBgDREYXDt7bfLsvR9nzEWx7HfYIQ6GJueE5TQSRq2FIIxNjXdaUR+nh5zHOowliYjz/N5mXUPxuV0W1Oyu3cwLEt2sH1daneGdabnL55/qjdQgAAzqqBUEpq+20/yP/nzr73w+islgQuPPsqCMBfcDXyH+KAxQbQZRjOdGQSwdnvvyttXm80mL2USZ/S571/Z29kNw7DZbLpeeOZ0u9vtXr2xhXE0O3didvr4tWvvKBWMx4pz13WnieoR5gFGDsW+4xrt2/f92fm5JM4eeeSRMAxXT6xcvHjx+LEVAkB0hhAqitT0Z3A9r9loYqQEz7UAYwqZls5c8aIolZBKcAAgCCmpldRCKHPiWdUGc1QWDCGfYcRFziF1tHCYZixAWGayj/hYpWJ5dvTGq1/90HsvvPbCMypoX3zywy8990eLc6ugFzc3Xjh2fAZjT6l9qZwkkY0pUogMEEMaEYW1BqUwlggpJBA34tJ2GDLyl1JalcYp2/SjUvgOoW/yV6T6FaqKnbBGoCkGh7EUoUIIIYTWTCktFYRhiDEWghdFIUSptfYDFyGU5ylCCGFNEQaMCUbInEQFOomHx44d29/dazZdLXiZpc3Qy3lKkABNpQRpKlMBA4BGUBSF0pJi5Hmew7DWUoiyGbXvW1p6+ZXXr75zoxmo0ShtzE9dvXVt3gno0sKpcxcgILMOZAk4TZpCiQGSYfbHf/yV777y/Qyp1fP3eczZXF9nvgeDES9KVfKm31hoz3rMIQDj/mDY7c12pka9/v72Dp1rLC1ESwBgTtOiGFZnjuP70OL87GjQHw+HD518wC1oZ6qNxurWa9dTZzQcDh944gnP83hZ+I2GKPn88rGl5eXHHn3XQ5cuLi4uBkEgJS+zlDlE81xrXeQ5YTQIPM55t7vX6rTH47HjuoQgSlma5kKrKIqKggvJCSEaZJ7njDEAMCedLszO3b51h3PeaLSFkEWa5EXsl6ETEM91qIYyz2RRiqIocJbG5YlHj+/cnvn+Cy9CVoZNL2Lh4tRyMeIvPfOdKJw6e/bs65f30jTFvpBKcF5wgTRIpDFRpu4WE4WxBi44VDksFoJ30VavxZygy6krefb/LMus2lf3v2iJyzxnjHnaS9McIRT6rlJaIL16/OSt2zeyLGlEQasV9Qe9VquV8sI8YX84mJ2ZubN2B2lohH4cj6Y67We+8bUg9BxKHMdJ0rHrumFEe/1hqzXteGG3N5qeXej1x54fAOBJRjBSGExLIIm07PXBm5phTnDl8tuBL2WQDXxGGrPrO1trrjj/8LEsh7KEVgj9JJFh2dBQJplHHapR3B/cuHL1oN/Dvuv6nuN4oDRwydqgZ0rKFXVhrj316Y9+fGVl5dUXvu96Ad1567I5TokicBhxGWUEU4Ku3bg86veTeBR5PltenBbLOIo0Qgd+3u/3V/Z2u/t7YRiurK7ed+HBRx9/4tHHH/NdVwCIslRKIFBKlzwHIQrf98Mw5EoCKIRoUcjxeOh53nA0NlF5zJzADYaDsed55qQhrWQzau7qXSXluTPn1tbXfL/vuq4eJUVRIESEKPM8CwJHsCbVoSiZKBEoVyKZcnUQ571srrX0Xp88xpMxKG8vv4/N+C2n9UNT/axUjJ6gmHluArLJiJKCIk0mzMsUPSIFCFd1llBH2A+8ag4/iaqCJlTVFFcdGWxbj7u1xkiZHkYSpDKVlEK5DsagNXXchYWFNBm5rhv6Xru5opSanp53XXdzc7PVbACodz3+aDwcRVEQBq7kxX1njlOKhoPepz/9SQLomWe/tbF548J9lz744Y/t7Pa++/zLo3Fx9vSpre09RKiZK2jBpVSiVFJIyV9ce1tt7YXhUtNrjpNd1yc376wlzbi5cnprD333W99/8kOPa4D9A+gshBmkm1dvzS8tfv7zn/nUZz59e3/7zs7W+v7+wbA/ThNc8jLneZzk+/3h5vYrzz6nuAj9xtbW1u2rV+NeL01T+tTZaYQQxQgjibQsi7RMRyLPZ+ZaeCZE0hUlB33gD+MI2o1G46VbB1lROIS+733vWTl5amZhaXpukTAn5WXKyyRJFC8bjdBhhGKktVYIuJJKqX6/CwDMdRijZVlkWRZEoeDKcbwwDJOsmNQ7So60klJSDACQZVmr1cqupHGcmp3mZc5oA2GdZ4kfuGPJCq7zvBACY+KWxBXKLVL06195jdIydIjmzXwkvnejlw6C0G80mqPRWNxcW+uNVDqacXSn4Uea0DTPFBZYC1RZEhpJNSn1qOSq1khXjQEt8mqVbwZbYEvp7tbIAbauv+qvJ/XKEoyebpxzuMCu6zLmGvt6ampq0D9IxkOC1PLSXLfbTfuAMX7nyuXRaMTL/PjysTSNMVK8yKLQEzwDVTaagUs/1mgGn/70hwf7983MzWFM2mcXvvKV7WZnodluYMowcRAQhIwjU4ISSpWgdSs6rRfOPvjgme437/zJv/7nJ6YXn3zPez/1X/347Ze2vvef/mMjcre3IQpgZhpefeutxqrsbY4QJYvOshOQk8tLq8eWBIAEMFpqWZRZkqpCKiHSUTwcDve296ZbjSzLvvDZT+/t7dEnLs4QhAjRLsWMaKRKUWSySFWZh65DCfAkGw/7SmTNkDhNtKFn+6NhyXPmhWfvOycAl7JM44Qr6Zpze6lHKOK85EVGEEaIFLwMgqDRamKMy7KgDisFJ5i0otbN27cBcLfbv3Hr9tLSsSCIKLLJL5wQMh4la2trb7311vbujjn1L83LINAuJXmeaq0K3NWIpFQqQojr54KXMhc+yQvmeTNdLh3i68jNoEnbUY+jaHucZmKrK91girCpIsM+aWRpjBnFWgOSeNLlCrQGXWvEdi/Ds0zRMr+K1R26jjDOI/KaaAUYY6QQ1lpqIcyRl0gqAKUZIZ4bjMdDjFSaRqLM260lIcTKysrz33sOE7hz53a7FSXj4fRUQ4q0LEZpPNzaGn/9a384Nz/98Y9/7NTiiXFSfO+FF+cWVstssD6K3f3+wvKpfm+oEAYAAggjSTAgpAhCaba9tjU86OOPrZ668PC7nv7Iw5e97LW3tp58YGl05aHN3b3LV25Pd47zpLtwarqQ20988L1Go9UKsAZEQWngXDQcCgDgOtp1MAAB0DBf5trzEAAUBbgucA50calRZnmejaUssZIuQ04gwddQKJ0d8DjHSk41CGgNxUGxu/nQoz+Xc96cn1VccgWj0ShqTTm+52IMAFmeKM4JYkoIXhSUIIXJrVu3tJbj8dihmPPy9OnTQRC0Wq3f/8Pf/8Mvf+XWrfUiL9M0f/LJp7/4xS9WoS20s7NDKY3H42987et3NtY5Lx3PDXy/N+gilCFEOC+kKNV0H1HKuOSgNGWaC60UChtiJArqpGNJpKDUHRVx6DlpmjQaK36gi1w7YQe7ajhOhFC8KH2KAYQGXZUPY40waGSqK6tMKlOPN3H4AcAP/GCRdgSvFeZ0HYIIS6QBYWBVC0EhhBCKEGJ8A4uLi1sbBWOM50W72eqOx4yxRhg1muGw102LPHCxVnxne3N/d2N5edpzAHS2tNR+9LGLzSaMdjZbndmPf+ipTMIvfPEf/K//7v/k2nEcJwyRUFhKJaXQGgmlCMYadNSOVqLjo7RwArh280789UF2YT6izo2X3yIb29PNaHNjb9CFa2+9+JEfvf++5XmRFxohQggmhCDQAAQBoVQJTQgCBFKC0kAoYADPQ1IBwVCUqesGjAGFqRNOkTt5ArIAVUCZ8nwoM+7RALDWGGFQQCiABu06uugXqeuH4+4eoj72AlPEmnE+TuKiKJJk7HvOwsw0ApmmsRRl0JrZ2dvlnPd6B67LpOCLx5b9KOz2B7/xW781GMRCiCCIEGLPP/di96AfNhXnXCsVx7Hn+b1eb21tXWrh+z4iGFNHKVXyQmuXi7IsczmtGVNUS6VLjQoocqawF3qaIpc6zShKuiUqRSZyBzD2+H5SUsy41qKQCBHsCMJoy6VCpoA4gNIINGAAqoACwghyqCK2BjHGnWZt3jrzs//XOdwRhldDM9JaE6S0Uhhh5lCNsFBgGt41GiEoynnaarZc1xWF2Nnenpub0Zp5nldC8cADDzz3nWd9302SceA7rVZrdsZL08FguPf+9z/1sY99oN0Me8Peyy986z3v+0Czs+ATeuIYfs+7n3z2uTe73X3Mmsr0D9bGFYlBKYR0fzzgztzmTtof3T+3eHxj+1r7gcWdg33SS/BB16Pu7mDj0oMrnc7slStXzz/8JPIYAiy1KnmhhMQYO9R1CJqckqyBEpAASsPkNRiUBtdl5htaJNOgBCaS+QgYAihYmbA8Hq3dwDJCqBCS64IzBI7joiabmpqCRmNnbR1RgYTSmJVSmGYNxGGBDnzPAYLKrEySRMjSa8+0p2bm52fzInVdNhr0F5eXiqI4ODjo94dbWzuq1GHYiML20tI0ADYquCnOGA2Gd+7cmZ6e9jwHMOzu7zFCplptoEGaKs6LssyH2mMAEimNgFCptNZSA9YEUVSiKbetZY9I7Qjp5zHDZNAUgIWjUJqMHXAdnwrBfUqVSgEpBRhpqhFWQDUw0JSg4m48A6GJWAYQWpkEO/OLu/IU2wL4yiI5KoXRRE2ccMtJ4xpKmQYkS2XqpsMwRAhR6mRZFoXh/u5Wlo6k5IsnFqWUlOHFufm5ublB/4AXCWd62Munp8Nhbz8M6Sc/8WHm4Ju3rozHI4LKbNzf3tlbXLlfE/9Tn7h/fXu4u58VCghm1GEYY6S0koUQXEuJGS2liJpTW7vjk2fPP/dH32TZub6Sn376h59eWv23/+rf5DrIzwpG3dXVVQw0B0kBEALqMOIwraDqB4DMSd1IT1ydAkADMFAIgeMQocq85LRE7ihx4kFXlkng4FZII9dlmDTnLox2tnf31uLeSJUFCJGnWZakUxl+9Kl3O47TaE8NM14IYU5eppS6rqsdBlpmWVYkieux2eZ0rhWXYjgebW2um7NrTivFOZ+Zm/0H/+AfXL16fao5LaVO4uKBBx6cn18YJteNn8/3/c31za2trZWVFddlw/Fwbf2O60czMzPYiXZ2BiY1tZsEpFBKK8K072NQFASWJSljmSdpuwFqICLieuA4mcRIJOGIIcdzfJ6kDvM9v5GOx4AdhEoAwEDVRAHFoKkCQg9ztSNXTare/cayvbv5z39BRToAaCWNookmLR+UlFJJ4Jw7FPlBkKWD6anZYf9AKw9pcBxnf3dvbn5GFOXqiePDQbfVbEiRIopu3Lh2fGX2x3/8Mx/4wA9dv3F5a2NtOOpHxejNt15tTx/rHuzOLJ1ACGamOuubQ00YQoCAaAW8LNI0SZNxURTXNr+dd848eOGj27v77z9/H/+yQoRIrV5/440ffXT1iaef/vb33nzrzcv3nZx+7dU3Hnx6zgFSgACtGCKm67viUglJPU8LxblEBAMlk97FGkoQBBGpJRe82+vSO43ShT65cT145ar71q1O2AaewZSfOOX3Du58a+PWm3s72G813E7azZhCH1458egPzxdE8UQlcRkE0bA79n0/pJQhNE6yIHRd1x+Wuev6gefJePjgmRUEZLnTLgouBTrY6EupAODUyulTK6elKpQSCAEmEKe3b7x568IFXyXqxKnTf/ilP/A8rzM1d9AdjGK0vycbzYbU5M6VO1zKxx5+VzOkzcKFsswLFLajwKMkJLkS+3Gc+NoJw5hvwIIeJJnHsCeASt0sTrgOm5+ev7b7zvUbt0+cYHPTS47j7Kb7FDNCGNZEC4Q1wiAwBuXaTBNt4l1aa6QVxkhKKaUGBBQIAiylllLOz6L3vve9X/nKV7Is++mf/ukbN651Op0//dM/vfjQxbm5meFwaCpO5uZnn3322UajcX72USfwv//mK2sHm26rxQOdpAIkoWPvzMrp0UHPxVNFrGanTm5u3Z5eWBr3VeDNDvtFM/LmZxan2rcG/Z1HH33gqScvzc81T6wuzs404jhutVqBd1ZKIbKYUGfl2Kmo0U4LUCU8fOHY3ubNnf0tx28LQbOcU+a3Wn6Wx1s7W3gU4INbJ86tb4wu9578ROPRh1579vLTTz8dcXZ5Q1/6wJN/9uJ3x+rWPuc7m7kcrThNicApRMEYy3JOKU2ytNkMx4UCjQEwkmCqug3RFchRyhRx+NOzx2k4HrOY95O4dGAQaaqHqEjK9a2c4lmGP3LigfdeevpAyq0449ilrnfs2LE4iX3f/8M//C/PPvNdrVGSZAsLC6dOnfrc5z6zuLjYHxxwzjudjhDl1tZWZ6o1HiV5nmPMGHWrOgZqukYwRl2XMYdoLYqiyIv00UcfnZqaElxlWba7u+u67mAw0FofHBycOHFidXV1OM7KQhDG5uZnsiwrRqXrER98lMpCcky5ophx5kvkaB8pB6SmSjkamMZE65znGU/jEcMgWqHvM8bLjJeFkqXSCmlASGFEAGGMMcEoKxFCGABjhAAUmM5aoDQgBBIjc9YFwoAJgARJWTkc7WnIES6lSv2AIizaHX/52EwYhuO4l+WjJOs57qzrod299Z/65F/mWu0Md3pFzBFSQhIgCLlFykf9kVZII00p5hoRF/UGB42o6QeRVKQockDywYcffOTST/zEjz+oFDAM4zHcuH5tPOq2281WM0RYhyEbp9newaAQzPFDz4UoCv2wwbcHWAiFMEJIgiYAzWZ0/Pjxbb3TIYRzQRjb2zt48smnf+/3fs91XYzx9vZ2eHLp/H337e/smPblt9cGD15sEAQmvup7rNsbeV4wHKYY0Tqztyw/EYUNI1FK6eJQaIX2Zdk+OU9mPZ2mamu/+9bVeac5S4NRphNKA0ZPPHT+ic9/CqKGzkdCCMact95664UXXuh0pvv94a1bt9588/X777/v4sULZVlqTYoyE6JkjPW6AwAURY1Wq+M6odbAGDPF0lyYFrzAHISQppRRSpEDYdDArhMPx1dvXC8LcWf9+uLSSlmW49Gw4Pz8hYud9vTN27eyLFtYaEUq5KMcQJUipa4SwLlWpdTEaShSEomhQKhABAiVBCvpU1WWJU8HPgXcDhwiyiwviiIMQgwIgekKz7UmWpYSIUxchBAGhLBpn6pNmx8lJZIEKWUiukIhpbRSMD211G7Nv+vx925tbfW6ybWrd4qi6B6kvKS9PCkLND211AjnGuHcqRMPDNqDOOsVUuRFrCRXUgMHB7kYHKJJOkrbzQgjgRnWUrKA7RxsU2faVaadpvBdirBza239d7+EX3/tpTBkZZb2e/uuR+47c/rEyVXf9RAeDYcjhPth0I+imc7Mcm+QaqBcIig5YgwwUUpxITzPW1heWJp70pyrSIvi6rUbjz766Pb27ptvXu7u7/KiXJiZHo1GSEM6Hi3MzwaeTxA56A7H4/HJE8e6vdh1fc+j3YN+FEU/AH9ImT5gumoMRJ20kFjvd7sjD5dpvyXEyaXOvFhde/bV1c5C/2C4r/V2SE8vL3ue34sHU1E4Go/SNDU9nBljjkO73f1mM3IcigkopYTQ43gIoKamppaXjzPGKHZM+5KqWRRWSmFEA99BSAPoLE+Gw3GWZadWz5ieixvrm7dv3zlz+lyaFxcvXvzkJz6NiPvOtWth0PDCaHV1tdFqbm1tH4xllo7aTVeLBAVI8MyLgtn2zGBYEiIJCCyZr1lIHM+hVOoM9TAuoRQhww3PYUxzpBwAgjiA1AohQBhhDQhhAgBljiYZL0iDyTlWQmsdeL5CoBQoCVojpbXSSgN97tlrd24mzWZzb6/Ixuvb27FSqtlcee2lrfF4zBgrivb1K+ObV1/udruBH32T/xlx3e2dbS0FczyPIqRdLYgoZFKMpqNIqrIUmGvht0Lek0DKUsZlXghZamhoLXdvb12+fLndjLpdDgBI+2kv//o3X1Nff4UR6oYjpcBhvgaqgLXac5RGB71x1OiUAghIwghoKHlOJKOu47iRlDIvBAAZDAbt9vS5++7f2Nh65KEHD/b2vvGNb3zv2e988P3vH496oef29vauami328eWj43HYnoqSlM42I+bzXaaxofwhyfqL/Y8XdUBCiHo11558cyZU6256abHbr2x/caVy2uZUNt7FxaODwG/09u+edA7IAiW5i+8+s7uoPeiGt5//wUhxLmz58Pwz7XW8/PzURR1u900TZMk6ff7rVZjbm6OEEIp9t0QAGd5lqYZwczzAs75aDTyfd9khWBsGGFBiDsz3cjTbDQaTU1NXX7nyt7e3vTMXK/Xu3Hjxtrt9ajVvvLO9YX5peXjq4RiRmjo+/03b77+2ktY56oY33d2FYEcjkdpKajbQDRE2MeaecSLHM9FBCntNXPTCsNxHC/wMMaEUUJIo9FU5nQTwhhzKPEooQgR7LoIASbSJC8B0gAOAMTxCAHGgE1eM8ZgkpkXF5cHg2GalN1uX3Ag2OVlqSTd3enned5stBwnLPOyLAuCIs9tXb3+kh814pRjFmKtoNBK5fmYO4iWpSjzhsKlLkGC8hqNxtT01t76scWlRrPBOS5FgTFutjut5hSlVJQSAzDqKikdLxFcMsaG6TuMOZr5gkNeSj0ug0D5UVshKhWAVgRjSoxQyEtVIorG49T3fUyAMn9nd/8DH/jh/+PXfq3ZbIMoji0t//W/9lPpaLB559ZUM+q02rs7Nz23cSCSX/qlX/rHX/xHnseSJKWURlFz4jAwKKzwJ2ppaVprOlho3VbpaDgmMZ3F0fkHnlzpdCijQEleFOVDZ+bj/Pba9vBg9Kf/4bf3dg+CH3386aff3e12T506de7cufF4TAjCGGZmpgaDQa/Xazabi4sLlGGEkEOdre3dZrPpMI9RVZaiLIXvB2HYMA1QMMZS8jRN06RwXOr7gcPcqc40dd1+fzgaxi+//Cqj7hV95crbV4HQLE6PnTjpMK83HJhji/d6Bc53l+emtu8ckNhtRl7gypEstrd2FfElMNDUoV7CHIZACTmOd6NmFMcxxthxXc4581zCqFYgAWmFMGWUOIQxjDEC4odTCGmMsfGwUjbJoltaPIYxxpSa0/AwphhRQkjpyLjoTwXTrRlBWOE4HnZLJxQCcr/hKLU7ynKEkBcGSqlhsut6LqGO5xHieEpS7QiGqa8Ew7jIFMjYcR0OUhMqgXrh1P7Gm81m1Ow0QydMkrTIOSiEEOFSMRrwUvaHCUE0DKdcn+Z53ppeRQhJjRwX+9jBxMWYIOyUhVAIKcCATYM8x2S++a2OUMhxHCklc9E7V26cO3uaczEYDBq+s729+9jF83/08vcfuP++uZmZg72d3/39LwNAp9N5880rP//f/KN/8S/+xamTcwfd3HGItTkA3XXLmxOLTMGCUkD54mw/KUpEunvj4tp2P01fHfdzqvdRthYP9tLEpWHAXXckdq/vBIJAlhWlAEROnj71C7/43wohMMZ5nh8cHNx//31hGHam2g6l42QsROl5cmnxeLfbvfzW6++8c+2NN9545513xqPEcZxGo7G0tHTxwQvnzp1rNpsI6UAGrsPTOOOce5732qtvMNcBgPe9732lEFfevrq6uqoklIL3B91jSyta62Q8Clz+8PseePrRi3/wOwcy2wLkM631cNhhWBFVApVAGCsdx8GgJRFsnHb8JuRSaO6ALnnCFUulCIJQCFEIY5pjjbBSCrTGpl7HuKAJmH63GOMXnhthwghmiFDQCGNKCCOElFGa5/ns7CxCaDSMKWUIEdd1PTdot6cElwDYNBnTWhdF0WBThJQll65fSqm10J1mixFeJGmRlfuqP79yHIPnOH6Sa0w7iwvLZVnu7Ow1wwYC4rq+6/oUOaNRDIgiRr2AEMIcL1RKAwfmzwAACIERcV1fSl0KRQBLAIoZIti0BiWEMEYAVK8/dl13HGeMMYycNOeNZvvxx5+4cvmdj//IB5PR+Pnnn3/9tddEFrP79cMXH3jfez+0u7v72OOP/M2/+V99/OMf/c3f/O2/83f+1mg0ktL0IVEIobuJuwBAJ0e/mCY4lHrNtsf8c40kv3Jl67l4c3sw7jZX594+2OwRicKo7brTy8dbGVl78XJvbeeD8CPj8TjP816vt7CwMBwO8zz1POfUqROrq6tJGm9sbDBG2u12FDUPDg5ev3X9t3/rd7785S8Ph0OT3mIOqxkMBhhjz/NMVzJCyNzc3NLywrDfk1IeP37869/81vT0rMO8uYX5r371z1qt1vb2JqVOpz1NCOaimDTyRsne7jsvvbi3s7H2M3/545//zGfefPPN//WX/53KpNCCYQKIElpSY+Pgkui04QMvCMYsbERRygAgzjLmolIQUmppOrUhUMqcf5krLarj3ZRWSCOiAXuuQlRiLEBjpTRojIBpwJo3oD/eL4cLS8vnTp985OHHTpw45bq+74WE0O3t3V6vt7d78Morr62trWmlsHQRQlKrMPSlKgiohdm25nnoOpxLQgO/yfypZZ/OjAvhOb7GG1mRYUUCP9IaFQUv8lIQRJmbjBMA3Gi0GHXzvJRS+qGfFoXruoQCAHCJszyXUkZRBAhhShBCZVkCgDlfjRCSFGp6ttPvjzCmpeQOI+NxfPbMfa9+/8WyLLGW80sL/8u//jff+PpX+93uwmL7nZvRiy/+8c2bt0+fPhkE0a/8h1/9/Oc/t7Q0J6T4AeCr5K/JZOOcU9qVgqCpmeVHfvT+bpb9u3/zr9N0RK4PY83B86goxnF/fzftOM25sydOXLp4/PiJLCvG49HCwoJprMQYa7VaU9OdXr8bRdHMzIwQIk1zjPHzzz//T/7b/3ee50JMarxNbFcI4fu+cc/mee66bhhGjDnjUfrUu98zGo2yLMuyrNOePnf+vmef/c6tW7cwosRhhJAkHYeBp6X0HKfMcy9S+3s7PD6Ym/POn79vNOyeOL6yurry4mu3kVdSGgJBGsq85AhrAC1kHgase5DMLC4SQihx84L3B7FUjgaMkCYITEUjwaC1LtIhQtrzvFyWvu/+/M///K/92q/FWc4oStJUaPC9BkKAKCEEBrt7Tue+z37+5z796c+eOHECNCoKnmVZmuRSasac2dOPBg9GMzOYUrhxI3nj9bf++E9+653r72TDbiJjUCkwfnDQRSpPKGLUabeXXnnp2x/77M/0B2PKpoqEzc8s3b59e29n36H+1NQUQUprHQV+WQqMIimlRqKUQmPNGGEORGhKqYp+NDDmEiKM4ShEKaVEAJRSrURZcKWU47TSNA/DUErpuv541Lty5eoHPvCBr3z5S9evXz9z8lie51tbW77vHV964PLl60rBFz7/Y+N4+KUv/a7r+mVZ/s7v/M4Xf+HvUEUneUJIIYS0mhxV5Drme00xcSijD06djtM4TsWb2f5otvPQT/woQ4qAXpqb8x0v9CM/iJwgcqNW0Gw5QRDp3sLCwsGBv9/r+r7fnp7yPNd1XcoY4XwYD/OsjKKoMz39n/7Tf/qlX/qlJMnKMldKOY7jeY5p/W5Kd02qAecizwvOD/I8j6Lm2u31O3fuUEoff9eTzWYzzwtzapLrYCi5KEqFwHV9aIDv+8xxpGSURUVZ4gKt3dnNxmVZljdu70TNcJjx8SBDzIk6rSgKhOBpFk91ouGoi7C+c+fW7MIiaCQk933f8T1jxkrQUk+STJXWkT/HOacME+wRTG5cXe/3Uq21UOA7LULYOM48NygS3upE//df/Hsf+NDfF0KMR8nl168LIV3XxxiXhShL0Wi0CNZb67ffep03Go2FhaUf/qEnPvThJy5ffuu3fuc3Xn3t+ajZHI22hvs323NhwfM80yXPTp19Ihn3fH81E6Ttt2V+O3QDEDodjUPX88OwLMuD/d1Op0OoRFhhbCpANcYKYaAoVIAwEI2lsd+lNAeKmOQK0xudEkIMO0gTznFhYoAUY621OZJyZWVlZ2fnXY8++Prrr8/NdNI0fXnt1sqxpdXTD+3sbM3PL/ziL/7i//gv/tn2zp033ngNIUjT3PjqqzgPngSBBLfNOQkhFDKhOZDQG4r41KWHn/zoh0OXEl4SrjyNCaKAcY5RjiFDwBG0x5Blxc7ODsL62LGlTqejtRKyjJMRpZQo4nqsLMu1tbUvfen3Xn75lfnOqtaIUsdUchFCDEG4HtNag8ZCiDTNhFCUOmEYvvjSS+12e3llZXp6+jvf+Y7ptd/pdDjnjLr2VDfFy4SXQghwfZ9NyzzOCv7d5y+3olAp2OsJcBzFQi9yJALBaRyDlLoscMshg2Toh2F3OJgnBCHsEdqanlFKKY0AQBrjrOKCSIZ5ngOA0kIDXHtnq8yZ43iglBJOWeh249goSR999H1/+2//7TBs7O69oLWO43hzY+vGjRt37mwMBgMhFCVOWZae5588efLixYf88NjG1jtXr+VRsBQ2gn/8j/7h62+9/H/+xr8fxbtzJ08Pu7cdyhGB0Xif8/GVt16++PAMUz4u83bTz8cwyEajfBy6OAycRuC4DGmZg5YYAcHEzAMhpLUoczMfabr3Ky2k5Eop4jhIS1BSa6TxpGRKSQiDkDEG2gPQjkuV8DDo8Xj8wQ996N/+0v/0+ltvLk61irL8zOc++6d/8kenT58aJen3v//9p55+fHPrdhB4cRxfu/7OW29dXz42b89mq1IoMQDkPCeEGB0aAGi3zPMycx2v1+0HEWu7TANQ5iotCtNrGyMgCBBgASCl4zi3bt362te+9unPfHJuZi4vs6LMhBBZlgVBwDlvNBoH+73f//0/ePXVV+fn5xFHvu97nud5DiEYkDKKFCGEc6lBUUoZY5znZVmmaTo3u+C67vzcou/7e7sHRm8ghAghMDHt8BWAloqbUupRrE+urOgS5WX80us3As+JoiY47XEhGXER8XIuoFDMAQczgsj+cC0MQ5mnmDlJWQiuCGHY8cfjRKGqMwG52zrIp6HnekIIIQRlrLufuayjNGaEFIXwvGAcqy98/q//9M/83GgYZ2lx9fofX37r7TfeeGN3d9e0AgcAjDHnkjFGiXP95p/86X/J/PbUY4899thjj3n0Q91ubzDcWVlZ+YVf+O++/cyfffNbf+gGY1UOAg9rKXY2bqXF/plTl2YXOqPhgXSG48F2OtptRC3J43FvK4gaUaPBOScEI4wJwUCozYGgQAAAY8esnmmmYzRaLrQQAIAIRtjEq0GBkqJUSnCtZSGLvEiLXN2+ffvhS/ebvm8PPfLwC999dmd7/fVXXxqNBmfPXhqNBl/60u9GDW80Gly69MDLr7y4t7ejgStlUkkkL6WpVkUIU4psMpGUkuq2kxyM83Ef0qwdBS0JZamYj0cgOSiBNEHgIRwiiBAoTZrNRqfTWVtbD8MwK7I7d9aYQ6TkpqR5OBybcwG+9rWvjUYj1/UJop7nhaGPJ60/J2qpGQPGhFGXUqa1zrI8z8oHHp5P03Rp5ZgpiRqNRoP+aHl5+VOf+lSaptvb27dv397a2hqPR6aOuiyw1MCFwpQVRSayMtOxoiyMWoXAcZ4roRrNaG6q7WCdZ6kIpufmFt6+/E6j0RSAgLpAWHc4qbGvRlWVHyOti5JSzEsZp2mj0eBSUccbjxPmEDcIi0L+9M/8zc9+7ke3dw6uX7v5/e9//+0bv7W/v5+OE8d3G1EIk7MecXO+GcexObcC42YSZ9/9zje+8+zXz6w+95nPfuHE2Qe2tze9qPHk0z/ih43nv/PVjdtvZOWIMTrsH3CRbK2/PttpQllefv2F4XCIlMKA87EeD5QCRB3PDyOCKWEOIowQhgkxxQMBbSKEMAHGmGIYIY20Bi1dxghCEmGFMMEEY6I1UhI4lwokAokQgFYEgQI9jocLCwsXL1544cUX19eupaNBPO5/5Ec+ePrMuTSNb6/dpBQxp8NFmWZxFAXd3u4Pf/C9WmspFeeyLIRSkwLQOB4a+2NC0i9deS3pD52yWGlNLbdONwkIjLnQc6GbApRaKqGpEk6JSKlRKQuPLi4dWz15gjne3sH+nY1112PDYV9Kefr0aURQKfjG1ubtO2t+EGVZ1mxOLNyyLEqeAyhCEELIKIXGZ+H7vuM443EyHo/ffvudqakpQtjm5vYwHpeCU0rbralXXnlFSjkej7vdgyLLkAaXOQ5lJSCt0rwYYxcWpufKMh+lSZwnIu67ramoHWmtHVB5PkjzNBmPPvSZ90dh89rtO8RxMfXCsEGJu7/fDcJgckYIwCTOa1iIKjSmQIRUuQTH8R1IudA5Akji+Od//h99+Ec+ur59+7VX3/r617+xub01PjhgzGmFbcdxZCm11p1mc3p6ejweE6+BqpOOXcgip0QI7e6+9q/+v987e+l9P/6X/2+NqaWSw4mT7/JZ+9lveTfe+T6CnJKMYvHWK9/QxRCwu9u9HoYhaLSxvqUU+EETEE0y3mh2CPMJdRF2KHUIcxHCSqmAOgghjBFlmFBqjqpQWkdRxJVWEiFMHSeghCmEtdYUhyY4hhBSIJlDMRAAsb6+9olPf+o73/lGmvbPnTqRZqOr124w11lZWEEI/vJf+YmyTL/17T9f9mf+6f/rF1dXj125cqUq1EeCKwBMCKXE8fxJY2qjcdJOO1qcaojBeHVuYXkxAgBKQXEOJXYxOBhRSlxAQAAYgE8PslhKubKysr293ZlqmMPvkiQxvSJnZ2cB4PXXX8+yzHU9xpjJY1NKAECr1ep0Wo1GyBwyHA7zrBwOx3GcFDn3/cB1Xc75OMvLsnzuuecODg46nWmENEi1ubnpeowxprVCeiKOS54LIRzXVToFnADwzmx7FJeSEemqj33ys6fO3r+ysqqlSocDMR7xNC6yZPni/VpDbxRffuNyKTQUnBIkEcbmeF9TxWEO2NYKa/ACoVROmHZDCThxfZyLAfV0kez//D/+hQsPnLpy/bWrV6//2Z9/c2NjCyG0OLtkfKLNqNlsNgnFWZYNe0PGGGEEIY0ASSkdQplHEEIapY125+att/79f/jfPvKJn1o5foEg74GLP5QluSp4f+9qibUs4r2dq5L3qeMFTQdpP8n43t6BkNCZXowabSUJgiYGBVpJIZCmGClASEnIsv5E+SKAKcIYKwRK637vQEgtNBDsOCygjouAaq0ROOZYP4VASsEYYQ4Rorx69er73vvU+3/ohyTPMMiFhZlmFD762GPpIP7EJz62tLRw+syJ/+3/9798+tOfoBT/5m/+5p3125RSShwAoiQAEEocSh3KpNG4Jvhr+d50u32Ql3ker23tOUrNTLcdRnheMAKEMIw0aAIaQCDQutWKXn31DSHE22+//dTTjzcaDeaQVqshJTcKnNbo+vXrCKE0TcMwJNWRBGEYrp5YPn/+3LGVJVMRt7u7+9qrb7z22huDfqy1Nqes51wTzOI4XlhYmJube/bZb3vM6XQ6eZECgBA8TdM8z5UWjDHHceIyBpwxR5VlpnHBZew3nHCm+U/+2T+enjvWdFsYtAtAQQBIFcfbAjjnJ06e/be//O827myNhjGXPAyj6rQuNTlRFZm2G0qJcZZnhFHKFNepBJqkvaDRfOLp93ZmwtZ08MLLz/3Wb/9OOs5ZEPAkUS5utqMgCAAgK/pQKEppq+0IWZpiZ6kEoYS5xDjAHKckruy0o/3bt/7jb//u53608cjDj9+6vXvm1EOj/fW3896Aj6QWjQaRcljGg0Ky/X3FhQJNMHbSuIcxDsNOZUxIqUDJEjRBBARXHvBJcZPRK4gGAKkRJlRKLRXWSHAmSclBI60RBqa0Nm2ycl46DnU9VpbZG2+8sXb72vT0dBIP5mc6eTqem5ne2dl5/pnvlDzf299aWv6Jz3zmM0888diFCxe+9e2vP/PMM4wxRl0AJAXSGhv8CZm4ruv7vsmpoUGvHO9tBYQmeXa73A0j79ruttKC88LkR1FKMSYmZqyUakVsPNifaTe+9a1vPXj/eRe7FGhe5hSxVhSWSTnuHgCHyA0llQiQ7zvD4RCQeviRC08+9fj8/Ox73vv03/pbP3f9+vW/9/d+/q/+tR9fOb70O//xdwFJc6wjolzodL+73e3vDodDLgupOUqQlNLzPI1AYBAYtCYKIa21H8xQ2s64bLYXNnaLLPcULx977PTGW3d0n6tmg1EsGSMYgVQOY8tT3gvPvdzUYrx1O0CgGJIS0jQNgtDwP6QVaIWrg3BigYLWTBhGWVbwUkuOoQxmW6uf+/hPTE9Pf+fPv/21//JHKhmEDBHFZ2cjIA2v1Sl53oy87sFupxUiEFkyQAgJzo3joSxLhwVA3IKLhvOEw0hSbszM83H27T/+8vcd8pOPPfa+NNYrp+/b6472+hqF01gOkvEOIqUjQkppUSRS6jCksiyT/l7oOiCcpWPzd7b2pmcWhCZZnhDHIwy0chEoAi7RUilzNBwwDIqXlILWSOtCiUQXk0RaTkuttZaUMeYSLEtUKub7YVmWGxsHfhh6btDNHMaWNkf4xNTqhQdvXb169fyFY/ML7X/6T//hK69c+Vf/8n/+8pe/PB6WACVAcqQOgVY2nvmS/sqv/MqP/dgX3vvep8IIJtWDGpTWUnKttVJSCFmWZdWHXiDgy8sreV42m+21tfVz585xzh3H45xnWSGl9P0wDBsHBz3P82ZmZkx7g9UTyw8//PDFixfvv/++0bj3d//u3/3ud7/7rnc9tjB/TEq9ubHzyiuv8VJ5nueIUilVlqU5UNScWsgYm5ub45wb0VaW5f7+vta60WgomBwD+9BDDx0/vpKk4/GgPzs7vd/rOozm8ViKkmoNWhFAruMIxl999dW93d729jZ1/LzQlAYI4aIojGeHIEBIIzzRgZrNZlEUaZpKqbOsBECNTuvd73730tLS7bWbr7322u7uLiHE+BfLspyajbQUlOJ+v99uN7N0NBr2Z6bb5rBjrXXJpeBKg3SJowMvHY4BBdPTnf3ufqvR3O8Pf/M3f7PVWlxePHPy5Koqi8H+5tqtfaXLMAx9P9reHTQaDdd1pdQIIc455yKO40azc+fOnSBs53mukGMOpU6y3DrbtMagiVLCTA27GCk9KdLQCCr1g3peURhWbfzEYEqiHEZZM+y0pwljruMhRBBCLsNf/H/84tra+sLCQhSxX/kPv/Erv/IrN2/eLIoiiiKbeVVPwVK8Oh8AACFEb968OT093WoD5xDHkot8ejrEgITQCCHGHNfFjUYDVSFkiqHkYnN7d++g9ydf/fPnX3zJ9/1jx45JKZvNpuu6URTlpRgnWaPVabQ6PC3zIr106dLVa1cefOjC9196YWPjzlNPPfnRj36k1Wo1W9G73vWuLMv397uXL18Jg4brugbrxjttAGeaJTqOM0mc9X1z9FQYhoNRwhijlJ48efLJJ5846O7Fw4FSgnPOOU8xiDzDUmKECIDgXLtAqbO7uxtFESIeIOE4AVfaHKJZ4U8SDKZPQcrNiTQCIaK1RIgAwHA4/NVf/dW1O7fW1m6XZe4HLuc8CPwgCIo8ybWcn51ev32NwPSlhy489uilY4sLU9NtIQTBbGt37+vf+NZLL72c5WJmZq6kZHd/pz3dmJ7pjNLEd1jaH/3B733pJ3/ib3Si9lS70WqHURRgkHmR7+4euG5kbGqT+kUp1RrKsux2u4XAFx+cTwqZ80QDFQqSJAndAE9UCqW0NK0B6gUAJksZ24ZJBEmppQJCECUUY0oIoQT7gau11rIQkjsYmOMVRdHr7vzLf/k/LS8vz8/P7+3t/fIv/3KWZaurq4PBwJwuppSS1WXS/kLPt7JUa01nZ6enpqayDACg2SRJ6gHAaJQwRmyelrFXDJDHRZrn+cUHL+0f9JIk+fKXv7y1teW6bhAEQoher2d43szsfKs9tX/Qi1yn1WqcPLl6/UYxOzv9xpuvxfF4fX3d87zLl98ihGFEjx079vDDD7311ltKC0ZpppQCwAgxSkFrXpa8LAPfb7fbeZ4P+n1els1GQ2s96PfHcdZqNOLRIMsyACjLstFocF6YGRrfoe/6lCDFhVJKCjE3NyelCoIgyYTWGpAqS44RNTaHBAWgECizR6WWvu9LocqiQACtRnPQG3z/xefTNC2KwvPcTrtZlrmWilHquW6zGQyH/e7B7v33nf7kJz5y37nToMrd7e1XXnn+q1/9ahJnn/v853/qr/3kZz79yd/90u9/5St/dOH0o+1WmMZx1GmkRe573vS55fW33/7mn3+18ang9OqJBy/e39u72d3fdyibm57KBOZcSqkdxwmDkBCGEMbUu3PnzvETZw4ODrDjS0WElBgTz/PKoqwaO0mpjPNLTw5jMj7hCRdEJhwAmahaoxqcSyEIx1zw0vd96rtCFHlalDnhnEcB3utv7W5tfvazn/3Ihz64MDtjeIQQoigKCz7OuYXgaDQyn00mAP2Jn/iJkyenxzEoJfyAUkqQOWWREOMhrDqeTNhm2Iy4Uo1286FHHhFC3F5fH4zH29vb+ebm3NycF4aFEHt7e4PxmLru7Oyso/jJkyfjOH7ve9/T7e2/9dYbe3u7L7384oULF6KwefLkqW996xle6tOnTzcaDdtdxeZnm0Oq0jSN4xgAsiwzqa9BECil0jT1PG1uS8dxmqbDXh8h3esdnDl9OklSUBorSX0sOfQH3fFgCC5qdaallEXBkyQl1COEAPCKJSBzjjVG2LRdcwihhBV5wjk3u95ut8qybLWa4/HYWP2MkVarHYWRlJJg7XuszIu/9IXPPvrIQ2++/tJbb77uUHBd98f/0ucopd3+8Fvf+PMzZ85+7rOffPyxS//+l39jdXVlfStJxsNW1MizXjaOW/Mzb7/1WjtsHJw/193fRppTgikmSmPqeFJmjDGt0N7eHgCenZ2bnZr7r//rzz7y2JO//hu/TVioCStKVXIZBV6GCq21lFwIAIQwwoQgc96YkbzmBE9jfACA1JoSxzjMyzLTUhBCCEUUYaTDjKjBsN/v94uicCnTxZl8tF6W5fKxxeVjM3PzH5RSHhwcmAPe4XDVlZW5Fpdaa/qe97+POJDzPMsSof0sT4PAY4xkSQyTYycwwQwTTAhDCPX6Q9d1s1ycOnmcS/jpn/lZqeC5554ryzJJktAL3v3udy8uLmZZ9pWvfGU4HObpaDweljxvtVrDYXd9/c4nP/XxTqfza7/2ax/+8IcRgm9/+9u7O92f/dmf833XNtnQVRc2k64thLhy5UpRFObkZsdx8jyfjA1hKaXrukVROIRGURTHcRynumpUpUBzLiUv+73hwd4eixwvaGBMjR3NHExoISW3Td8IIGy64yIAAClUrnLjNx6Px+N4iLBuNBr7+/tKiyxPtBLTMzNBEDDGOIdhf1dK+fGP/ci7n378v3z59zY3bp89fSIMvN3d3X5vf3l5+dyZk6+++tpv/sb3Hnzo4U996lPvefcTL73yMnMQoYxhNDc9vb6514imxjz/zne+/sL3vuU7yHNxsxlKDjvbeyXhZVm2oobruUqplZXVv/pX/9rn/9JPzkzPRW36h//lj/vj1Hc9Sp2iP+S8ZIxprbGpLZAIYU0pJoRgSibKnzInNaCJLEaKUqqUkEIhhBzXdVzKMCry7M7N63mRgpJz8zMnj81NT0+fP3/u7dd2fd9vhOHBXt/3/Sjypjsdz3PyvLSAq+NPTnrFTiqm6TPPfHt+fr7ZihqN0CQkx3FMKWbO5FBdwZXWfEIlAFG7KYTo7h8YHrm8NPvTf+Nnf/QLf4lznud5p9M5c2Y1y0Qcx9/89jMHvf789LQQotVq3blzO83ibrc7HA4xBs6LTqdjztHr94Ym4G0RzzlPkkRrbRxFxlafGFCUGke0EMJxHAS4zDOXOXt7e7u7u+Y8gtnpmaIojAySUgqlMCK+HzZanVLlWVaAxnEcF6UcjlKle5g6pm84ABDQGGOr/wGljuOUZUmIOTRLmRwcynAz6Lgu45w3m02lVJIknueFgcsY++hHPpglo9u3rs1Otx2Gdnc39/d2wrBx9erlra2dksuHLj5w/PjCq6+8+JnPfuL6jSvjOA6DIM2KRrNzbIHs7nUxaKI5RlpwMcpz32m3WhFaXE4U6fV6mFGl1HAwAliP4zj03H6/X/LWYNDf3T3oTIug2aIEEax4WSKEALQ5m0RrJcSk/gxAaUQQxghhPDnlhoAp3cXguhCEvkMJ0pyX2bC/3+/vtJvNxx55+Ec+8qEH7r+/0QxPnjwWDz67vr7OGJud7QBAmpZCCIydIHAs5lStZ47JiK4sEqCvvPKK5zsLC3PNZtTutNrtptbSdd0g9BBCJqcXYzoJiwL0uoOiKMz5qxjRaze2GGNLi8cqJR3t7gy63e6ZM6cZdR3mJckYY+h2uzMzZ6TiH/vYx77xjW/cvHn94YcfppQOBoMPfOADy0srnucZF6AqJAFUcJFzQQhhmFDHdRznwoULlFIjc82LTGoG58IPwyzLet3eCy+8kOUJxthltCiKZhghAODSYdR3XD+IGGMCBGDaaLR8L3A8VHaHeVaErouqKl2sESCTewoAIDnHAP1ud9jvO8w7tXoCY3zz5k2kZJ7E3f09hPDC3AwjRGjdCMNBv/v0U+9fXVn+j7/9G77L9vd2Xnj+mb/2V/8yRmo8Hs/Pzdx//vzNW2vvvHO53+9dunSp0Qg+9rGP/uff/VK/3w+j9qg/DPyoEYZpmiouQUsFwnFJGPkIcK/XB79VFHx6evbY4lIQREaT63a7cVrSfv/kieNCSOoxDApACl4IaTrfI0wQAsQlKCWk1BhjjQlGgDEiposgwQgRyZVEGgFQh7kOQyCG/dHB/nY2HhxfWfrExz78qU9+7NLF80LK3sEBAYUJPPzIxcuXrwShZzIIm2FQFNyavUYK4UqeoMMtdejSsUXGmBe41GEKdJKljBGZK6E5ANSOUZwcQ0BcFxDa2d+/y1E5z7tdADBUpZTCjO11e2fPn79y7ZpDgBCyvb0NoB+6dGFlZen46rGXX3751KlT3W53OLj95JPvRsBeffW1OI4dxzP+GkJIlmUYY8N7RqPRN7/5zSiKpqamWq2WOb8vSZKiKFqttpayGUVRI0ziGBMSBEHoewihW7dubW9u+Z4Tup5LGcUYY5yVabc/XF/fIIRtbW5LDYwxc5afUqrRaOVpnCTZD73v/T/903/9/vvv/4f/6IsPP/LQuXPn/uzP/mw4HG5vb7daLaWF49Ktzc2V48d/7Md+7Lvf/a45UmbQH3me89BDFweDPmOk1Wq+9uqLZZE0mw2CliilXhD5ftDudLTWt9fW19fXCG09/vij33rm23c2tl3maIV5WVIMSEvQHCHNyyLwGxjjPC+np2a7KQeNFuYXm81mr9f7whf+0he/+MXAdwFAAfziF/+xGzb/2X//P75x+e1mqxPHMaGRkoVWCBFQWilZaq0xJVIKrLWmyJQtA+KUOpRO2jm4rpvnKWhx//kzv/29b68szj39wR/+zKc/urw4V2Tjd66+k2fjYX/Q682kGTd2XpJMHBEGCWYTTZ6LwaLxY1DPNV8aONFjK0vmODLGCJ0ERSaF+6CxxlqpibWvFWitBRRHJPoEyJSasucsy4zcPH36tOd5DFCSZC88//0f+sB7X33l9QsPnIvj8crKytTUFAIS+I0b12/FcVrkfG5uYX19syjF5MwtIcyZzbo6RddMknNuMtezLCuK4vrV66aASCnJlcQYuy5zXdfzHIdSl1Hf8zzmOIwwTBBCy8vLiJIwDC9evHjm3HlMmdI6K/nnf/QLL7744rVr13hRLC8vf/qTn3rqqacwxn//7/99AGi2otOnT7/wwgtf/vIfrK3dbjabnPOf/bmf/bEf+7GZmdlXX311bW0tDBrNZjQe9xuNhjmNnFLcaIRL506N4+Gg1zt//rzGyHUcx/WXl5dvr63HcfztZ7/1riee8DzPdXzOpRCKYNaIgjwbc4oQBimUcaBowBpo1Az6/b6U8rOf/dz73//+xcVFDGh7+8D3Q8C0M9VCBF984Py1a9c8l4H2MWaEeFyUaZoKxQnGXMhknCjQhDCCKRCKwBwZhxBCgRfmedobjqZaralOo91ufeYzn/obP/VXzpw+4boIg1BlDloiNKsk57woODHGrK76PQghNAAXSkitNTdhHruD2Jm8yFghNAgCjDGl2IAPm0JDYwSA8b9IrRGaHHWhKGJHTBrz3DTL49HIIXQ8HGqtZcmPLx+bbnfKwc5oFE9NtTc2Ns+ePbW+vhlFQZ7nruM/88yzZSkIZp3OzPXrN4VQjuPwUiJMMCAlpKaKESqllFxQSkXJJRcpJAaRUkqtVBAECCGtlUQAZHLkuJRSCIU0RxqQLrWQvCAUYYTQM9/+DnEYAHCpECFho0kZk4D+5E//2HGchx+5FHp+lmU3blzf39+L4/jYsVWM8drtm81m887t2+1mK+2MFxcXP/GJT5w8eTIKwhvXro0Gw8DzXcdJ4hghNDU15Tje1NRUmSeXLj1y+sxqkZdAcNCI8qw0VhNznTAMG40WRyUQOHHq1OZWT0mkFUIEKSUxRpgohPQkYwCw0CAU2tjY+Lv/zc9/4Uc/f/z48cBzdnd3iyw/efL0aDzmXDZaU2mSnzp1gmA96h90B8NmYyoMQ6VFkccFzzHG4yTp9Xr33X8BAQFMTOHV5IQTXhwkY0JI5PuA1K3bNx577MEnn/isE7jT0+TgIPVd0uw0x4NhGHiuy0bjwVxjqkLLRLKaE3JI7RBx0+jIKHxpllv8GTZJzWH3FVdTRu8x/hdjFplc4EqL1PoHnewDACZUYLQ0c3zcpUuXvvtnWwSzIIh2tvdMUabneXt7+1/72tefeeY7Z8/c99hjT1Dir62tp0leecuRtX8n4t9xrMfSminm9Og0SaT5HgHGGChRShszGSmMNNdSKUGNpYw1zM7OC63SNM3LRAoBeOx6gcbozTdfl1JTSmXJ4zgO/aDdbptC6dnZ2fF4zBjZ2Fg/eWp1ZmbG990XXnju+eefp5RiRLvdLsZUa0QpxcQpuECUHFtZ3dndfODBi1Pt1tbmnZ3tvXeuXJudnQ0iLAuZxNn5By7Oz8+nXO8d7M/MzXGhXIcYX1I8HhmPHSCtkdJIKY2UxkrDpz75mS98/sdOnji+trY21Wo3Go0yL27evN7pTOd5UYqDUoiVY0tPPPH47v6Bu7GVp4XmOYCkSGFKvchfmJ+B0yclmGNdiQKkTE8RRBAiQeC3Wo2drQ3mhCdOrPb7/TffTBYXZt95+w3XIQ9dfADjmcE4zspidrpTlGq817NWoxW1RgTbJBejBRqxGwQequmAtD3VqriYaW4izcypw5RSUmrQeGK0YKSVFiWHqn6kjgkp5dTU1NbGZhiGRjnLsmx5cSkMG47j3Lq5Nj3T+s6z33v63U+kaYoJnDp1ZmH+WLPZzjP+4osvxeNUCJnnpTkjryxLMwELvn6/f8R1ZCbAKMVKSaUwxpgSRE0euRwOh6aJBsGYICCmhwFCoecDwWbAQqlyPB6MhqVQURRJybWWDnWmpqYoJkmSDIcjjJyDgwOEUBj6hJCNjQ1KcZI0dnZ2yrJ0XX9udsGsvtbadfxcxlfevvrEE49Pzc61O1MFl6WQfhguHTuW5rlG6OattbXbm1u7ex/76Mc556+8+uq5+y5s7+wQQhEiMGEeDJBCeHK+DZ7UGRMNqCj4N7/5zcuzs2WZN8MoDDyEUBiG29u7jusKoRwv6EzNfvCHf7jX749G8euvvjYYDA4ODiTPB8Oh7sPi4uLiseW84ABII2LytTChRgRnZdFo+jNTF4oyHw8Hly49+MilB/70T//knStvvvupJ1zfK7jEhJZc7nWHoCXzAisGxeSUMsPqEEJgKhnMVhqA8qKo3YCo6fENoBHWAKyqNdTmNHlzvMqkW7vWoDHGYhIUBKW0FFIYCMZxjAnaP9hL0kAIMRwONzc3Z2Zmji0fv3nrupQqSTKE9EsvvTw11Wm1GoQQrdGNG7cP9gc7O3vzc0sAGEGWpAPzQEKIcWqUZWmOqteWD9e7y1sPuaEQbBi29H0fJs09JycdmBkPBiNEiVE1NEYKlAaNkO529x3Hwxgn5ZhzCUq7rut5vsOCvEiNf9Hz2WDQcxwnScZzc3Npmvd6vY3NO2HQbDZDhFBRFIjiNy+/7XlBu9W5ePGhl196odNshVFzPEo4581WBxDb3O62Wx0/jL7/zDPPfu+7v/CL/+TWrbV2Z7rIVZokGIPjOHlJMMYYa0QwYASApMZCwbVr127evBmFfrPZjHwvDDyTUOj7/szMnJDa9UNESHtqRgjluO5jD1/s9nq9Xq/f769vre/u7yEQWvI8S5RGAAgRl1CHEIYxAQDHc5LxaHPQa7VajWb4la/84de/8dWpVmt1dXX11ElCneE4ZoxiQGmROY5TpJkVWeaaAIvSyqMwwR8BRBAw11e11okmUVtbC4UQalTAPC+10fsQqs4MAIwRQVhppU0fHmlKq6RSynPcfrfnUJaMYyllmRdlXnT3DzzP0wrNzs72+72p6eadtQ3O+c7OThAEQshBfxSGjZVjq1Kq9TvbaZo2W76U0ohXw/bMWE1EuDbOiXuSaHMQGyitFWiAyY8mnwBr0/KjyqgH8JnPNS/LUgNojDBFmBLGGJ7U2giHsXZ7SkuVpmmWZXkmmEPKsux294PQY4w4Do3j+LXXXp+bm/U8ryg452Wv12OMNRttTfDW5vYLL750/r7TrXa0u7vthUGRJb/ya/+7UurSpUuf+sznjh8/PhjGd9Y2Xnn5tU9+8pPb27uD8chlbUodpVNCSFnGCCHAYMpQSikKLouCF7nMeRxFEYA6ODjI4rHnulEUmAJyx/EQpoS5SZZGUUNqFIZhw3EUAuNG9RzWabeUUsl4NOwPhAKpAIAgwjCmRswLVSKEFhfnsyzRqrx06cHlpaXu3t7C0lKelXc2N2VZep7nOlQpRSlXoE1BmRG1GGNCCSHEBAisqUoIwQgAoyK/GxrFGKM3b+6YpjpG+FqV0ZjlUmolwTSAAgCtkBKZqs6wM5cQwiDm+vXr7XZ7Y2MDIWQi4vv7+z6Q8Xi4tb2htegPusvL85RhrdV4PG63O2Uh4jhXEtK0kEJPTc3sH2yYilTDmE0Y0Zar3BvPASGBYIyx0nriW8cTVq+1tPjDGhBCGCFZSIUAE8CEaIyE4gomMsNxHCm14gIhwotSax0EIQKmwaTmK0BKSi5EqZQyebVpmisFM9NzZSkBYHpqVpDY85wn3/X4P/8f/ilocfP6lc2Nte2N9bU7t773ve9tb+3+d//Pf2oS5TGimzu7P/W3fuaf/w//n2997fkkVjPtxfEoaTTDre01QFmS9QBEmuau3+y0lobDosiVF0xar4aB1wh8XpacF57n+b7f7w893/fCyDC2UihCCBGCUoooRghRh7muiygRSgZhJBRoTTChhPmUOqCxAo2IMsZsv3dw8uTJRx992PdcAJhqN5USnstc1wUpTVAAkPJ93+joZoNM1NT+qKvjT4wuSAhhiKha/yv01vWtozsKAJMMiwlOjcJnFC9rHJg2sTYvK8syc2RjlmUmEXUwGIzH46LIiqJIkiRJEnOGjLUeDHCh1tFWKaXzUX0YdRPnCJO3XNCMDSaHjGJ7s/HJGUPKeG0opbqc6CKVC34C1qKml9T/JwjbFTQDmDgOaue0m+mYWnqv4Q8Gg9XV1b/yV37y05/+tB+4N25cu3NnbW1tTSrueU6zGWmtpRKzs7MnTpx49aXbv/7rv37nzp1Wq9Xr9QAgDMP9/f2yrPJVq6nZTbXDRrWL2sKeSkRMpkAJqvnLzJ2Gnk0esnHa2Q9OI0IIua7reR5jDCPKGHNdNwgi84Ex1zA8U7Ju/3ccx4gRs0omiQFP2mUjw4ABoKjqL8020R8IPqjUQxv1Mh901c3Tbr/jOAZGJtu51WqZ4+3yPDcZIvv7u3mej0ajwWBgEJllmSmTMxUoxpiw+GZqkrJGqsu80e53fYlNLqBNprAKolLKcRwzSSupzWdZNdOwCiRIhRTC7OhSGOBrcx5JhT+oOj8bUkSVcVd7NTQajd3d3d/+7d8py/Kv/NWffOjSI8ePH5+bm2MOKYosjmPfd2dmZhCGwWDwB3/wB5ubmwBQlmVZliZdHGNsmJBVlXTlBLWLoKsA9xF4HcGlVnfHiSbnyYMhRSmlfZ39bOSmYRNSSoyoeW9ZCsdxfN933Unm+b2sSghhJZVZE4M/s2iGEQhz6I1lE5dvbB9ZdPu5zv+0dbnZfauMX/O/cTubQRiLwQwLYxBCmBqROI7jODb4297ellKaO0V1SSmbHr27/bW3mDg6VCzdfm94qrWIzdoZC7rOXO1nUvVqPrK7ltLsBM1nlzLzo101+3xUKdiGqRgWUkoxOzsbRZEQZRiGjz768Mc+/pHHH3+80Yy0kr3+QVEUrVYjTdPf+73f/fVf//V4RLTWjuNwzuM4NvED42HWNd9WHevonstO897vFTr0J4YtGcI2Yz7yP/JchJCphXAcByPqOKZ22zcfKHXqvNPzPPujlbxmQcxn60ebePTuakdaa03tut9L/X8Rbdm9r6+OYTNaaxNNsffE8cgw52azWceTTW+u409rXaZjgyeDY1NkaXmk0ThNRwQj942npu6ROUIY5kc5aeACsijq9hccFvH3/mhGBfZAEACNQGnt+J6lEK21BG0qZ6emZ3r9QZJmMzPTaVZ8/Zvfunr92sWLFxcW5lZPrMzPz+/v7z3//POvvPLSYDBgTuAHBCEUx3GSJMYqH41GcZJ4nmfQhOvNorVG1lOL0N1/xv1rIweH91EpVdc36gL6Xn555LKyyIhXAyP72LrsQnVTA+P64utKdwKAKuNam526q1LUF91SOaqpOOZXtlFXPakVqrQUA3ZUxWE451NTU/XHWkyPx+O62LXPcdmCxZAVrEopw88Mv7Sqp0WntYQMOqvkNl1nsRP+7VCrL6LD+twPXAct5L3y1+g0kw8WrwAaoCwFQiRJMs53pqen2+2p8Sj72te+sbS0MBwOOS8cx5GKj8djKYXneZwrzvlgMOCch2HIOc+yzEi3I5ysTjPoCCire458b8imzqftb0ntwrXr7hEl1bzMw7MsM2hznKp0ktK6ULLUeO8q6cprBlVQzUoSatWj+iuPzMGCz36wZGFfjxAyPAwq2W+0GdOxwCCjzqVsf1ZdM5EwxsZosJOxl8GijTNaXmgAauBlbjBfxnFshmRgan8LqjT32HWx6Kwvgl0KRmhdD7GslHOOkEJI2S01t61vbC0sLHSmGmma7uzuZ0Xebrcd19/d62EMCDEuFULUD6LxeLy339PKMU+njlMKEcdxKYTx4R/hcBMfWF0oIWTZnrZMsfb9ZMPtiV/67j/jmMeYIITtP4CJHKsjskpGRlYDgRr/qwvTukCw7NMsrMGi1lrIif5nfrzLTo/IHVQzPiyfUFWSlb3qf2hEvh2E67qO4zgVv6kzOQBI09Q8wbJxMyzH8+0TLJet4xtVUR0zmCNkU3+XkQJ5npslMGwyTfqGR1r8GQZp9Vf75+YGnhcWc4ahTgr3K35vvzc49p3Q6AaO4xDCBv3RaBh7vuM4TqMRIYTG43FZ5o7jIIQQMC6EruodTYGS+ZX5v84Fj7C3Iz/ae478StVURhNLMf+EUoaOQSmNECiFlNIIOXD0Mn/LmGMUR2s6GJlrRm7BanltXQWqP0qrQz9O9L8jSLKY0zW/Q30VLB3YrTIizAR/DQ8zPxZFBpVOUKeSKIqsZWB42IT/SWXHV7+fMWbUQV3ZfWb7TZhE1Yxfw2iNfq21to1+tdaccz9YNoCzs7Y/1rms4YhKKV6Ulr/WGfmk+0dZWqFvXFE8UZgWWZbFWQqVxaPycjCKu/2+WUNCSCGkgazD3KJGDF4QMMayLPM9r75PFkP1DboHKj8Al6TiQ1Cp6eYyC26teMPJoPLbW3alKFR+BmECoY4z8fUY+Wt5pNnuI7Le4sRKS6wn90+wdGtrYCdW55x2DnbC5gPn3ELTgoYQYvV0O9sKl/xefV8pRQgxYhFXTb6QcQrqu7z2yF/VnWEW+tok/GhtoG8Ym3ElWEXEGh8IIYRFnUDtRQgxAt3y18mP+qjtP9lXQowaamZh9YR8XBh/52g0Go+Ho9EojmNTOTA5XXWyyNq8xSQ9WM8ZqvxzdiXrF0KoHhk3uDGDybLMpt/Jqs8iNqddVQiwD7T81eydNSwwxsDuOv8QQgQzY3kQwjDGvu/7fmi2zHGcIAja7bYhToyx9QKa1TPPt7Mzy07duxwWIUStMngEbXVSq3+wPNbuaJ3x3ntZk9liWtve+5Sa+VtqI4QYRcus471ArFOVeSyuvNAT8qrcTpayjzxByAwO68vmV8anZe0SmIRDpMFfncWa33LOq9QvLWsOSAe5Na31rj5qWpSUZZkXqVVbASBJEqsMWTrBGBtZrGtKsPmx2WwaJXviThPCzNfkz9YXSleaut2II1LSbgGq+WU01tYXjTEm2Pw0wZ91XCOETNDF6k424bSOE/N2M2BU+cPri0/hsDy1aKvTev1D3Z1r0WAuq6TXH2XYkkVMHX92XSrkKUOvdf3U7KGqcg6UIvY5Sk3+RDFqn0DJUfwd4euluKtp2Atq+kZ9+trU4teYpZ1amqZG4kDFYs3zi6yskyVUcoAxVrfTLVbKMjevs0hVVebSvfqAERT2HvNAu7xWkTDQMYDGh326loatCxBVruzJjxSZOEcdf5TSIIjQxKvn2NlprW0hmPnRQM3Qs1UWLTM2GpEVsBjju/C/F39wj/C1c9C1w81QTSms76WdrYWmHY2FrL0ZV4aSqTOu4w8fVhzr45wscY2grUludRHLPyaDod4heFVTs/Ja19KtEUJa3tUs68NoNBr2+zojaYTNI5aWqvmrbZzeztGcJqIrEW9pWB4OC1kWiPGkY7i5xyrEdZ3VMn7zXH2Yf+uK38MPEl9e6B3KJ0DUIrX6f6LzGTmrK8cFOqz5HQGckc6u6+a8tPdjU9WhK/eMGSX8X15H2cNhTlmnMPvBfl+H75EbLDSdCYC0VgqZw2QJrvCBj7wOIVQUCiFsnwnVKbr2RUohKUGC+QYc5h8hMPvhXnlt9Sd1+NJam17qxtIyszDbTxjWSEmupJLVPlGEkGf6B+hDVh0A5Hk+AXFN2TXf/8DVNl3C7H5ZWZxlGal66FpmiRBC4hD91LfS8FFSlRca3hy1A8ufAADBpICDczlJIGBWIhOEkIlzWj+i/aBqWSNQCUkr91Rlb1FdM5WtSmeZ2RFQ1/f+CP84Aosa2o56Po8g1apcR95Yv6fOa+1mmB8NUdo/wZVpYh9lWcjkaeQH+9ut/6/ORLXWlN71T6maIwYqdlsXMQDQ7jSMOWxNJYzuGgp27HYRrB+nDkqttemgdS+RG3hZjdk6QXzfN4JSVZ5R83Z5uN+KvaxiY+0DM+wwcuvLAhpX90PFFO+qgFJKz/OsBxtVBo3BnxViliq01phRXbOO7/r/6qOsK3n/F5flc/c+ofaru91G7Mzr6qABvZmPUgppaegOYWuAK9CAtMQIY4Q1mJOuTCARSQwUA0JISmMVYq010hOvFkJII0QQ1pVY5xrqo7UfjAKgqpYdZnHVYYeA1XK01nmeW0eGQUOj0XAcR2NuNuCuB0cUSinfC+9hZhgATN8SAwW7YfoecW/xZyLFqhZmMPgzxhAcNu0BAKrc3CNbZl3HuJYoBQDMQfZvEUKGeADAqH1KKc4nfQHsQ+oWrtXUrUS2rzC/tf4gVAloav/Mgo9SauxnOMz8LJyhJingsLFssVWpfUf1P/vndq3tQzDGSk48IHY+dml+4GUhUn8OmNyNaub2f4yxEqYSpgJfNQnCHOPYQ1VlidH9ZckRHHX9AwBFEx6Q5zmXynPd+fn5mZkZ5N7V5KRU1qrIskzJibPTRlyMXWKXt45vCws4zPxs3hqq6cdmE+tsD1cFjr7rHdEczKPMsRdVa9pSCGFsDkLvYp0QQvBkeKY/MQAQApTSKIpMaeJgMKjyEmhdPkz4fAUyO9p6vENKiW7e2be5CXXttSgKSx91rKhaMPuIln0vO7RkhGoqqrlkLXRTfw6qWawWlHfRULm7jrBtXdMfrHZsR1hHuRUQRiLYgJ5xYVp3xpH1stO3poBpxm3Uf9d1m81mq9UKAsdhfxGd3P2g1F2MclFau7huGtt4jCU/MwXmOJPDESjVlb3JGDPxpB9AJ3SShGc5pZoED+/6d+ubhV1W3zi7+5zzupPZLoWWk7wErbUhYKiyFWXVQQVXhmk9DGGmdoj53Ysey13qS2l/W9daLN6PzMrg4MgiHsGZfYtdu7rItrixOYx1wOHaVefi+vBVw4Gyr5a1eLRdbqh8lpYJ1S9ccz0SQkz1qpHC4/E4SbBWpRmMjTSYp3mea6JflAIAAqAAJuPBn8wIwI4FISiKScLEoeQJrVUttcym/1ibuj53s6pGLzQAsr4C022iPi+7zhzuZtzVV8nYGRaOdrkc17OowgTZMISQ3MCdUAM4RSl1XUcIgQBpDZgQAKC6svzt082LyT1xYSvOoZafYsdxZD71XdeHNZI6m7RyAWoZi3WYQs1MqXM1I4DqhHUv44S/4DoyqbpiZ2H3AxFsb4YqodLmJCul0jRVSiEQ9s76ZHXlY7OXuccPPItXjBHGE43Acy1ADw8eQCqoXCvSOPxw5a82K2NT2oz+Y1L0TMaQnZ3N8zi6WaCtiECVN8BKxfq8LBeUVesmu6fWLjHTtBlJlina+yfhGgM4u6PGLKrj5sjr792V+geo8dG6QgC1KFCd+anK7q6P7MiHSUlvTe5bNR/XNOj6aO99moUCHPbRoyr6Ysd5hFqOEAOupXVYpjsB8eHyPPsc66A+spLQv7vfddFZj48ZqTdxcFCMEBCCMELAsO9N5H0j8u0gDUDVJD+3MNlcJivC4swIcXX4AgCqJKr07zoR3s2DtJoMwoCAUGYFkdWbOecIASipQQNCGDRBAEoqwWnNSQyG/0FNnKGaIl+/dE1u3rsflivUAXpks+sf7v0R7mGZR96IKquizndRLe/VAt0Sbv2xR6jWDs9qpfVf1WnG5gVakNn5HhmkuaQyEvxQPTZCqL5/hzYSTXCsK33GfE7T9AjiJ3pwpX9baJoVcF0XWYuSEkYRAIEJHwUACHwGUOW8TQww0BN9FPQkL0vneaprniZ5OLH8iIUBAIQwzrmUgBBihqdrUEgrJQ2LrbyFTGuNQDmVs2yyvHX01PUnm8J5ZJV1zdjENXsW/gL+ZxReVOPkqnK41LetDrsjL9WVHllfF6jcp/WMr7qKeSRdoD7Ouoy2+23Zv6oxsCN/e2Sclk/oWvTCcw8ZIEeeU/8R31OeAkb8mVQdZfMgQYPJ9dAIobwscK2igFSpaMaStaqwUQwwxiZd3jycMWbsIyGk503O5yW43isD+W5YrZKdu3HigtYgJdSVUV1LSrfrwzEiCHzfN4UW9awoKYUota6JPmoXwpK+GXedxxzhw38RYuDwVf/eorzOlurQt1+qeyxWVVnW9V2HyvuvKn6AasaapZP6eOrDhpq1UVdA60oI1Ph3na+rmpfefm//xNJJ/dJVGtiRiSOEDL+xK2CvOt+t6wmYTpyOvDq3FypS1FWZX/1Rxm9stVv72c60fiGEHHo3jEEIJgTMmqEqe5DSiWJqXmKwbdCJqlOlpVSE4DwvbLaUwahlqHaj7+LPrlRdJNnPdt2NX6bu/tA1rV8fDmDoykFQ360jdx758i8CtJVfuHJ32WznuhiqY72+rxYo9nVW39K1CgZdM8PNB1P3XseiGZvBmeEEqIpvIoSKIocav6zr4HUSsmtreIO6xz6zOLYrP7F5lYTDpIiq2Hf9e4unJMlc1yWE2GIaw7ONfK/fOVkZXhpNzka09cSPQ238rVJGEUKATHK1qbNGMKkUpxgAnMgFcCtmNMGxMT8sk0E31vZQzWyBKm/UNiS1oWiz38YCtanIxrsjpTSFmDZXxW5zvVAParJPVa4TSxNmelJK63y2zrY624Ba6lcd65YJmT8x77Wbau+x4sBUtpsBmNoLVIVxjTQx2WyoSnS1j7KYsHzCDNWMNvD9OpVbkjAPRFUCn11Sxu6W81gCM7eZdTCOTzNyxlheFnV6rlOR4TGGEsxKCiHMwQqolvpg3R12U+oE71LIskxUx17YgaGa0kVr5eVB4Fv7g1Jqq4BxzZVmfjIcVKnJh8l21NlDnc/X2cmRQdib7bTNcC2512clq7wSVLNsdC3XzYLDokpWHdPNuwzB2frw+p+gmq8LKkld5xn1m81lnWdWwbARICuSrCF8r5FrQV83xs2vDFyyLDvCa81mGNhZTmOfZvze1m2Lqshsnf2gmu5v/RJ1y8CuWx2aE46oDi27qnK6vFp+9aElJdrxPGYdYRWbmHQsMeRd9Z/VWhdVJQ2urHjztCNaip14q9Wqv47aX1h4WeKu80XL7XVNA0M1MVfvH2D5kGFm9W2zl2FCR4QI1OwGcx0Z3hEwmT2rmx32XXX8HXl1XdKhKvXS0In1g6jKIMU1u97eX0e8fRSu/Gr1THT7KwOg+nPMjGR12f2zsuUIiFHFRFUtKQtqosawAMt7DGnxUh6ZeJ2Z1denWt67RCKrMhpCiG2BV19PK7WgFue1Wi+qcSv7YTQa1UdyN9Vb17SNuhBUtSQfcjjHGNUcRXVytPPBtZSWIzgwAqLuwTaDNgqKVZN1ZWHBX3AZl6ZdVkt/db2zPgYjU46A2FKafaOq8g7vfXidudYfZb5k1LV5qROzQCmtkFZISeP1wAiQNvsIUJa5lWt2MJRSUR28A5VuZ3BQl+zmBrMFRvLiKq5oF1ZJ240AmZU2VoUQUh/eGnMJfTeGBgBSSaQVYMMjrC2CAEArhRAuq+dgrAkxQDJHihBt7kQITIUeAGhQ4i49AMBRf7QdkPXrylpQGFXSyobA7d+6rlunSMvS6n2rLAOzcLdbjqpCuLqEqjPCe5+ADnO1I2D6i676Ay2YrKSzqp59vqj13zBPMNO0/rYjQ7WOYkuocDjoZ6m6ojqgVd9jISYtoDAmZpaHHf9Ia1QUE73cPN8o/qBBSQANWpmSZy6qQliTtwI1i9A8yvJvqLFYAJCgSymklEb/MxmiXEmuDtVBI4QmBfmYGr4lpVZQ5RxB5ZirwGeXiLG7yXIAQK1dZvXKIzuha5qWqsVFzMZY+/9IvATu6RRht9+uAq55Xixq6/jWleJsmNy9EMRV0pRdGsuc6vp1HZH1BHdUE9N1koC7wmgSFKnfo2sRv3tJBdTd0mszeHt/nZzsGGwup82zx1UtRZ1s6tZJfdH04QiYvccYAYQQCxhdqbMVLundMdc2izmOUFIjwJRQZxLPMH9reBjClUEBoLV2nYaqnLJHVsM+1s5ZgwZMtNamCl0pRS3jObJtxslk8W4Zu655d+scxejXVhWzv62vV33C9i11iBvtpw4aa2Oqw/mM9qoPso7y+v7V32igjKtQsnFKWRQe0fb0PXlsulZcAvekbhiKt15JCyNjN1hWauU7qlTquioCh72MR1CIK1lcx6Wu/EHmIrVUZHsOjF3/+nt/gGlV+TQMQI+o/rryW1ntKE1TS/x1Gq7vkblBVpVKdiRKKWrzGVVVW25+YfpT1VFsYGr8AqgW/9GHjfMjhguupSbU8Wf9C1BLokQImZMvj1h/dieO/G9pw6Knvrv2jaimbpuSLVQ53kTVZso+qj5+rbXVH+qjVZVDrk63E49tVfFl90lWp3je5QTVG+GeyKHVW4xcshqeXYq8yourI1VVjiTLh6w7sK5H2nHWM8br3AEAVBVW0VVlNKoSInXtsqaC4BMwUELrtGT+5AgolVJS3KVYjAi6fHVdVQEoWjUsss5YuMffUxSFaWwAtQgYpXQ0Gt0LPrM3pkUc59zUNIRhGIbhwcGBIQjz53bcnk+PIAAqlbwO37v8T9ythNWVHmn8CzZCoLW2sUhSy3S0zENXJTyoKoy13s0jK17ndnZfLRC11l7l/1NVKrXl30a81lmpUsq5Z2vN9OM4JlXmQV2KSVvYe9i1bhNaLd+tLxccrvYwB5jZG1DN8Ld5CRbKNq3fWD8micF1XbM41jQ8Qp/2HillnudGQ3McRwKySyGlnCjLqoqo2nna/a5P1W6n1QmswGXsUNwTVZaK+UPDZmyub1EUFu6Wk2OMHcdRuqy7DC31yFrcxr4CAAhy6vhAlassSZIf6D2p21tHkKRrSoJ9SxRFE8KtgcwsLtSUhB8YxrBPxjU/QF2wYowNg5nIvprAtUf4QSUfLM6OsHxcCxtaq9/ShqF5jLE9w0wpZYIfdSJBlYJoNFGLPFxL/tU1BdQ+yiq4dS4LAOY4UnXYOYoQUnIS/Td/SGktH6EuSmxLCl0JC13lA9vR6EoXhJpfQx/WZ1Gtb4v1qhiCsJmxNusYYwxVvXddfumauVrnFgBg8GaZpYWRzUS3u2VhhA8brZZF4VoCIqqCWnWlrf7BChRUM/Z1vbKoEo7osBZhEWY+F+XdfNX6wGyHJKjsCcOH8qo/hn2FfablCIbZ1EdVt95M1moQBHZ4Vo+yFKurBqZ197g+bDWa7w0d1vFjlsXmYln2Yd4r4W6NEsaYGlZkCQiqsniDvzqngcoAlFVEqC4o4bCab/Ubg9e6Qiaq9lOq6qtiUSWEwATZfa3LKfs0izxzST4J3VomYVQfq0QfYcPqB1nHuJY7bZfevD1JkvoK1GWuzSg2+zTRwyq72IzziEJmvbX1JYUas7SEdMT5YOFuCdvSgKksNn3xLOgt4Ky/WtSak9YVqjqdq0ohttO0NGCjRLpym9sdrI+zjj+LSCuXpJRAqIUpQoimaWpoyy6ZFQpWalj+rA+LP1IL1No/sRO7a7dX62J4klUO7K7TqpNcvZmklZX1b46wEEt59sc6C7GbrWuyr8757JKZV9c5CqklYFpw1F9tTStSZT+oqieBHUkdZ2b7LZe1fNQulx2bockoinRN8VBKTRJIa5oWqsIndmoGhaqmqtqONnblDU3atH5dc6KVFTO2I6kTiXX62qU4YkTbRdZaG/mLKh+TZRyoylc11yRSVJdoNvhj4ahqTQhscMlyUV2LiNQ5lsWchfJkBPfodlZD11rLWm8KqCWc2lEdwYE5mN1yuPof1snXCuL68Or0Smqx+TqyLafUhyWvWQQLBYtmWatrrKtEph/hEfDZ5a1zO6ubWxyrelz7BwWZoPIn1G1w89vxeGzq3FCtotSysSN8ztKPBZbd1on0lNI21kC1PHB7WVDaH63MNKvEDsfoqOd56nD/eDOguv5XX3pa9d6qb56u2RZ1nKEfpH+gyr9gTBYrnS3iLcjq7NNOuP5YrTU93O3VgkDZhoeVVWvWxdQvilqd28Tu9jxccxWZdbC7YmFnzUybH2+ncIQT15mBha/hKPV9PQJfu3+GH9dxNuFSVfLEkXW222S5kXl4fV7mTlUpwRZGR16ha1meuHK92UFaGpZVxLw+ZQv9usw0K2w+C32IkqllvABgGs9Y72Wdr9qpysN9fexl9dkjiotVLHDNL2BuM0RptChZHbuK9F1N1G4/qlxQdfCZ3xJ0SDfQlUlk6rXqQLRLLGtxQotRowcrpUwg1RIYORyHqDPyugSoz7eOPKsn1YleVdal+R9qQt8q5qa6to4ncxkJa4MlUOmUnufZuchaT6ooikxvQou5Okew5GrhZUSzrPqpkaoNko0rmv9NNqFSKgxDO/06+dXj0XUOYvypuPKBo5deu2qGYrrrY4xNWztj/1usqEo78TzPOgjr4sxCzbzAFiTzWj9dqEw5SqkxgU1jPNNJDgCKonA9YpUVs4JCiDzPTb8VWctQnJCaIrLmv7XcyOyTQZis+vTcq2xYBiCrUn77RlXV1OjD0sRcompMrbU2HjUz9yRNG40GrlwhRv2IoihJEjNmVXVcNY8lNSW73kXAeFhl1dmNUmrE6HA0MqVlZuksnzb6lkWYQarneRsbG+ZgEnMnqvlHLY4JISYMYZoIWtPVTNl8P6lOr2VC6CrdGn7QhWolOJZfSikn53lW16SLPlQBN/MhCAJ12M6gtUZxdTXoiNzUNUdJ3ew1N8uqg5ihb0O4supVam7u9/vWd2BzSO1yWJehUsr0v2fEqxOAFb6MMet/NrATtd7U9WWq/1+XRGaV6+dI1aWYtazNstp0XSvo7fN15dfQlYZgmRAAOLVsTbuMlNI0TXHNANJVL3WozoSyBo3ZadPHw87FCoTJMTLV261NZkwNO05Vc73VR2Jo0myWiSNYJeTIYh75YNr506qtClR+lXGa1fkltSM2bhHDdWmVnAc1Z6aVg5bNoJpCZrgx1AK+FnCW2eJaXrvpn2JfLao29lEU2TutX0pXGonVme7iRk183VZqo6rFjF1xyyzrtkVdY9OVv70uIi1GLbnXBXed3VoHp+GFhBDblg9V+hY6nOtQn5flyvavrDVtoQm2vxYhRp5qrU0OqQFEFEWGxuz6mA+mQl5XFoBdJXNnXQU0CLN2mF0ZA0Fzsq7h6/UuH6KqUzvyf73FgpVOlFIrr82X1O6BBZzVKuqgVocdOXUE2AtqOqz9W3XYk2c3wARn8OF8Nc/zlL5bJ6GrXk9WntZFvyEGVbVDx4cVeXHPiUhQC1RYpbPOC63pZ4dt+ZxlafV31TU8VOlejuuqqqe+tcms9mJfYRUjK0ZRrb7E8K36pKyO4dTiLhay5nVGrFt/B9SsQ0sDULPPVGX161rfSKip3VCLoxplySr3pBbptnsKtctA2f5KV35f5vm6phZTK09xLc5dL6OyPNlsWJ7ndbqp03Qdf6qKKZOaP9bwCfOrRqNhMW3XgjGWVOd5Woib73Utca3uDqTYtd/XoWY+2OlYosKVvmWHamijroPXB6AOh/4sksyQRNV62miNdoIG35TeFS91NziqGUwmH0JV3jtcy3/Wh6u+LV51rapGVKUh9mQUVeVGmHmZejHzt7gK7hudW9Yi5nVtT9dMKysNrAfHkL3R2YwQR1Ussc6GbJ8kiyujP1D3UOuPSZwD1TLpZXVBrcWd3WDOeb04qi6mVc2pZqEjq3iXrvyc5rY6xM0GEEJc1w3D0PIeVaXkYIzH4zGr+sKimitLy6N1ApbEoRamtM4C09fHkpZdaEt71hkJNWv3SPRTV+1+UZW+Xy/9r+t/9QtXSU1Qkza+71sWaKdmTJk627bbbOx0w+GM6Df62WQ7a/tSlzyWl5MqsmryhXWtmsK8yORTWQtP1/xEqpYJryt9FB0uCbfUZbcP39MKB2pqADXrdYQJ13UCG5wwtEWrOrw6I7HyDlVxMItpCyZ0uPusMbjqAzVfSlXYdTGWOKryUOx4DlFLlZlvdTszvHoFk9UllFKmT2h9fe0uQi1SApXUs/4IqPTROnMllZdKVH20ZK10yNInqvqJoUoKW1XSWFGWtqFWaWo5Mal5uev2gSU2QsgRc0TVHEyWnRvgmhtMZopVN3EVyzF+hiNKNqqsN7ssdr72yyMkh2uedlHl0hNC4jiuc3RqyddIDcPbTTGl5bRGuKjK5rIcS9X8qPoe486M20b26i4rqPxY6nCZhVLKcSczp9WpnpRSz/OMPQgAxnFj2Zvn3M0TsSg3CLAnzxhuYc1hNjlHdJJ/as5QULVG56RWmxIEgSV0S+WqVqJm7Q+oiVdadX2wYzP2Fq2aptl1SGtmgVlzw8ZMXKBOP7KqW+O1/rv2Go/HlvbMnbiKi1hA1HVBY8QYQVyvkW00GkbPwzXHhXmmTVqxcsMyEXtZvl5nQPUcnyN5Uv9/PkmYPuNLYVYAAAAASUVORK5CYII=\n", "text/plain": [ - "" + "" ] }, - "execution_count": null, + "execution_count": 5, "metadata": {}, "output_type": "execute_result" } @@ -109,7 +139,35 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 6, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "torch.Size([160, 213, 3])" + ] + }, + "execution_count": 6, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "im_t = tensor(im)\n", + "im_t.shape" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "That's going to be the basis of our independent variable. For our dependent variable, we can use `Path.parent` from pathlib. First we'll need our vocab:" + ] + }, + { + "cell_type": "code", + "execution_count": 7, "metadata": {}, "outputs": [ { @@ -118,7 +176,7 @@ "(#10) ['n03417042','n03445777','n03888257','n03394916','n02979186','n03000684','n03425413','n01440764','n03028079','n02102040']" ] }, - "execution_count": null, + "execution_count": 7, "metadata": {}, "output_type": "execute_result" } @@ -127,9 +185,16 @@ "lbls = files.map(Self.parent.name()).unique(); lbls" ] }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "...and the reverse mapping, thanks to `L.val2idx`:" + ] + }, { "cell_type": "code", - "execution_count": null, + "execution_count": 8, "metadata": {}, "outputs": [ { @@ -147,7 +212,7 @@ " 'n02102040': 9}" ] }, - "execution_count": null, + "execution_count": 8, "metadata": {}, "output_type": "execute_result" } @@ -157,24 +222,10 @@ ] }, { - "cell_type": "code", - "execution_count": null, + "cell_type": "markdown", "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "torch.Size([160, 213, 3])" - ] - }, - "execution_count": null, - "metadata": {}, - "output_type": "execute_result" - } - ], "source": [ - "im_t = tensor(im)\n", - "im_t.shape" + "That's all the pieces we need to put together our `Dataset`:" ] }, { @@ -184,9 +235,16 @@ "## Dataset" ] }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "A `Dataset` in PyTorch can be anything which supports indexing (`__getitem__`) and `len`:" + ] + }, { "cell_type": "code", - "execution_count": null, + "execution_count": 9, "metadata": {}, "outputs": [], "source": [ @@ -199,9 +257,16 @@ " return tensor(im).float()/255, tensor(y)" ] }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "We need a list of training and validation filenames to pass to `Dataset.__init__`:" + ] + }, { "cell_type": "code", - "execution_count": null, + "execution_count": 10, "metadata": {}, "outputs": [ { @@ -210,7 +275,7 @@ "(9469, 3925)" ] }, - "execution_count": null, + "execution_count": 10, "metadata": {}, "output_type": "execute_result" } @@ -221,9 +286,16 @@ "len(train),len(valid)" ] }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Now we can try it out:" + ] + }, { "cell_type": "code", - "execution_count": null, + "execution_count": 11, "metadata": {}, "outputs": [ { @@ -232,7 +304,7 @@ "(torch.Size([64, 64, 3]), tensor(0))" ] }, - "execution_count": null, + "execution_count": 11, "metadata": {}, "output_type": "execute_result" } @@ -245,7 +317,7 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 12, "metadata": {}, "outputs": [ { @@ -265,9 +337,16 @@ "show_image(x, title=lbls[y]);" ] }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "As you see, our dataset is returning the independent and dependent variable as a tuple, which is just what we need. We'll need to be able to collate these into a mini-batch. Generally this is done with `torch.stack`, which is what we'll use here:" + ] + }, { "cell_type": "code", - "execution_count": null, + "execution_count": 13, "metadata": {}, "outputs": [], "source": [ @@ -276,9 +355,16 @@ " return torch.stack(xb),torch.stack(yb)" ] }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Here's a mini-batch with two items, for testing our `collate`:" + ] + }, { "cell_type": "code", - "execution_count": null, + "execution_count": 14, "metadata": {}, "outputs": [ { @@ -287,7 +373,7 @@ "(torch.Size([2, 64, 64, 3]), tensor([0, 0]))" ] }, - "execution_count": null, + "execution_count": 14, "metadata": {}, "output_type": "execute_result" } @@ -297,9 +383,16 @@ "x.shape,y" ] }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Now that we have a dataset and a collation function, we're ready to create `DataLoader`. We'll add two more things here: optional `shuffle` for the training set, and `ProcessPoolExecutor` to do our preprocessing in parallel. A parallel data loader is very important, because opening and decoding a jpeg image is a slow process. One CPU is not enough to decode images fast enough to keep a modern GPU busy." + ] + }, { "cell_type": "code", - "execution_count": null, + "execution_count": 15, "metadata": {}, "outputs": [], "source": [ @@ -317,9 +410,16 @@ " yield from ex.map(collate, chunks, ds=self.ds)" ] }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Let's try it out with our training and validation datasets." + ] + }, { "cell_type": "code", - "execution_count": null, + "execution_count": 16, "metadata": {}, "outputs": [ { @@ -328,7 +428,7 @@ "(torch.Size([128, 64, 64, 3]), torch.Size([128]), 74)" ] }, - "execution_count": null, + "execution_count": 16, "metadata": {}, "output_type": "execute_result" } @@ -341,9 +441,18 @@ "xb.shape,yb.shape,len(train_dl)" ] }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "The speed of this data loader is not much slower than PyTorch's, but it's far simpler. So if you're debugging a complex data loading process, don't be afraid to try doing things manually to help see exactly what's going on.\n", + "\n", + "For normalization, we'll need image statistics. Generally it's fine to calculate these on a single training mini-batch, since precision isn't needed here:" + ] + }, { "cell_type": "code", - "execution_count": null, + "execution_count": 17, "metadata": {}, "outputs": [ { @@ -352,7 +461,7 @@ "[tensor([0.4544, 0.4453, 0.4141]), tensor([0.2812, 0.2766, 0.2981])]" ] }, - "execution_count": null, + "execution_count": 17, "metadata": {}, "output_type": "execute_result" } @@ -362,9 +471,16 @@ "stats" ] }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Our `Normalize` class just needs to store these stats and apply them. To see why the `to_device` is needed, try commenting it out, and see what happens later in this notebook." + ] + }, { "cell_type": "code", - "execution_count": null, + "execution_count": 18, "metadata": {}, "outputs": [], "source": [ @@ -376,9 +492,16 @@ " return (x-self.stats[0])/self.stats[1]" ] }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "We always like to test everything we build in a notebook, as soon as we build it:" + ] + }, { "cell_type": "code", - "execution_count": null, + "execution_count": 19, "metadata": {}, "outputs": [], "source": [ @@ -388,7 +511,7 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 20, "metadata": {}, "outputs": [ { @@ -397,7 +520,7 @@ "(tensor([0.3732, 0.4907, 0.5633]), tensor([1.0212, 1.0311, 1.0131]))" ] }, - "execution_count": null, + "execution_count": 20, "metadata": {}, "output_type": "execute_result" } @@ -407,6 +530,13 @@ "t.mean((0,2,3)),t.std((0,2,3))" ] }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Here `tfm_x` isn't just applying `Normalize`, but is also permuting the axis order from `NHWC` to `NCHW` (see <> if you need a reminder what these acronyms refer to). PIL uses `HWC` axis order, which we can't use with PyTorch, hence the need for this `permute`." + ] + }, { "cell_type": "markdown", "metadata": {}, @@ -415,19 +545,62 @@ ] }, { - "cell_type": "code", - "execution_count": null, + "cell_type": "markdown", "metadata": {}, - "outputs": [], "source": [ - "class Parameter_(Tensor):\n", - " def __init__(self, *args, **kwargs): self.requires_grad_()\n", - "def Parameter(x): return Tensor._make_subclass(Parameter_, x, True)" + "That's all we need for the data for our model. So now we need the model itself! To create a model, we'll need `Module`. To create `Module`, we'll need `Parameter`, so let's start there. Recall that in <> we said that `Parameter` \"this class doesn't actually add any functionality (other than automatically calling `requires_grad_()` for us). It's only used as a 'marker' to show what to include in `parameters()`\". Here's a definition which does exactly that:" ] }, { "cell_type": "code", - "execution_count": null, + "execution_count": 21, + "metadata": {}, + "outputs": [], + "source": [ + "class Parameter(Tensor):\n", + " def __new__(self, x): return Tensor._make_subclass(Parameter, x, True)\n", + " def __init__(self, *args, **kwargs): self.requires_grad_()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "The implementation here is a bit awkward: we have to define the special `__new__` Python method, and use the internal PyTorch method `_make_subclass` because, as at the time of writing, PyTorch doesn't otherwise work correctly with this kind of subclassing, or provide an officially supported API to do this. This may be fixed by the time you read this book, so look on the book website to see if there are updated details.\n", + "\n", + "Our `Parameter` now behaves just like a tensor, as we wanted:" + ] + }, + { + "cell_type": "code", + "execution_count": 22, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "tensor(3., requires_grad=True)" + ] + }, + "execution_count": 22, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "Parameter(tensor(3.))" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Now that we have this, we can define `Module`:" + ] + }, + { + "cell_type": "code", + "execution_count": 23, "metadata": {}, "outputs": [], "source": [ @@ -446,13 +619,11 @@ " for m in self.children: m.training=v\n", " \n", " def parameters(self):\n", - " res = self.params\n", - " res += sum([m.parameters() for m in self.children], [])\n", - " return res\n", + " return self.params + sum([m.parameters() for m in self.children], [])\n", "\n", " def __setattr__(self,k,v):\n", " super().__setattr__(k,v)\n", - " if isinstance(v,Parameter_): self.register_parameters(v)\n", + " if isinstance(v,Parameter): self.register_parameters(v)\n", " if isinstance(v,Module): self.register_modules(v)\n", " \n", " def __call__(self, *args, **kwargs):\n", @@ -465,17 +636,29 @@ ] }, { - "cell_type": "code", - "execution_count": null, + "cell_type": "markdown", "metadata": {}, - "outputs": [], "source": [ - "act_func = F.relu" + "The key functionality is in the definition of `parameters()`:\n", + "\n", + " self.params + sum([m.parameters() for m in self.children], [])\n", + "\n", + "This means that we can ask any `Module` for its parameters, and it will return them, including all children modules (recursively). But how does it know what its parameters are? It's thanks to implementing Python's special `__setattr__` method, which is called for us any time Python sets an attribute on a class. Our implementation includes this line:\n", + "\n", + " if isinstance(v,Parameter): self.register_parameters(v)\n", + "\n", + "As you see, this is where we use our new `Parameter` class as a \"marker\"--anything of this class is added to our `params`.\n", + "\n", + "Python's `__call__` allows us to define what happens when our object is treated as a function; we just call `forward` (which doesn't exist here, so it'll need to be added by subclasses). Before we do, we'll call a `hook`, if it's defined. Now you can see that PyTorch hooks aren't doing anything fancy at all--they're just calling any hooks have been registered.\n", + "\n", + "Other than these pieces of functionality, our `Module` also provides `cuda` and `training` attributes, which we'll use shortly.\n", + "\n", + "Now we can create our first `Module`, which is `ConvLayer`:" ] }, { "cell_type": "code", - "execution_count": null, + "execution_count": 24, "metadata": {}, "outputs": [], "source": [ @@ -490,13 +673,20 @@ " \n", " def forward(self, x):\n", " x = F.conv2d(x, self.w, self.b, stride=self.stride, padding=1)\n", - " if self.act: x = act_func(x)\n", + " if self.act: x = F.relu(x)\n", " return x" ] }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "We're not implementing `F.conv2d` from scratch, since you should have already done that (using `unfold`) in the questionnaire in <>, but instead we're just creating a small class that wraps it up, along with bias, and weight initialization. Let's check that it works correctly with `Module.parameters()`:" + ] + }, { "cell_type": "code", - "execution_count": null, + "execution_count": 25, "metadata": {}, "outputs": [ { @@ -505,7 +695,7 @@ "2" ] }, - "execution_count": null, + "execution_count": 25, "metadata": {}, "output_type": "execute_result" } @@ -515,9 +705,16 @@ "len(l.parameters())" ] }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "...and that we can call it (which will result in `forward` being called):" + ] + }, { "cell_type": "code", - "execution_count": null, + "execution_count": 26, "metadata": {}, "outputs": [ { @@ -526,7 +723,7 @@ "torch.Size([128, 4, 64, 64])" ] }, - "execution_count": null, + "execution_count": 26, "metadata": {}, "output_type": "execute_result" } @@ -537,9 +734,16 @@ "r.shape" ] }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "In the same way, we can implement `Linear`:" + ] + }, { "cell_type": "code", - "execution_count": null, + "execution_count": 27, "metadata": {}, "outputs": [], "source": [ @@ -553,9 +757,16 @@ " def forward(self, x): return x@self.w.t() + self.b" ] }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "...and test it works:" + ] + }, { "cell_type": "code", - "execution_count": null, + "execution_count": 28, "metadata": {}, "outputs": [ { @@ -564,7 +775,7 @@ "torch.Size([3, 2])" ] }, - "execution_count": null, + "execution_count": 28, "metadata": {}, "output_type": "execute_result" } @@ -575,9 +786,16 @@ "r.shape" ] }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Let's also create a testing module to check that if we include multiple parameters as attributes, then they are all correctly registered:" + ] + }, { "cell_type": "code", - "execution_count": null, + "execution_count": 29, "metadata": {}, "outputs": [], "source": [ @@ -587,9 +805,16 @@ " self.c,self.l = ConvLayer(3,4),Linear(4,2)" ] }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Since we have a conv layer and a linear layer, each of which has weights and biases, we'd expect four parameters in total:" + ] + }, { "cell_type": "code", - "execution_count": null, + "execution_count": 30, "metadata": {}, "outputs": [ { @@ -598,7 +823,7 @@ "4" ] }, - "execution_count": null, + "execution_count": 30, "metadata": {}, "output_type": "execute_result" } @@ -608,9 +833,16 @@ "len(t.parameters())" ] }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "We should also find that calling `cuda()` on this class puts all these parameters on the GPU:" + ] + }, { "cell_type": "code", - "execution_count": null, + "execution_count": 31, "metadata": {}, "outputs": [ { @@ -619,7 +851,7 @@ "device(type='cuda', index=5)" ] }, - "execution_count": null, + "execution_count": 31, "metadata": {}, "output_type": "execute_result" } @@ -636,9 +868,16 @@ "## Simple CNN" ] }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "As we've seen, a `Sequential` class makes many architectures easier to implement, so let's make one:" + ] + }, { "cell_type": "code", - "execution_count": null, + "execution_count": 32, "metadata": {}, "outputs": [], "source": [ @@ -653,9 +892,30 @@ " return x" ] }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "The `forward` method here just calls each layer in turn. Note that we have to use the `register_modules` method we defined in `Module`, since otherwise the contents of `layers` won't appear in `parameters()`." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "> important: Remember that we're not using any PyTorch functionality for modules here; we're defining everything ourselves. So if you're not sure what `register_modules` does, or why it's needed, have another look at our code for `Module` above to see what we wrote!" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "We can create a simplified `AdaptivePool` which only handles pooling to a `1x1` output, and flattens it as well, by just using `mean`:" + ] + }, { "cell_type": "code", - "execution_count": null, + "execution_count": 33, "metadata": {}, "outputs": [], "source": [ @@ -663,9 +923,16 @@ " def forward(self, x): return x.mean((2,3))" ] }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "That's enough for us to create a CNN!" + ] + }, { "cell_type": "code", - "execution_count": null, + "execution_count": 34, "metadata": {}, "outputs": [], "source": [ @@ -680,9 +947,16 @@ " )" ] }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Let's see if our parameters are all being registered correctly:" + ] + }, { "cell_type": "code", - "execution_count": null, + "execution_count": 35, "metadata": {}, "outputs": [ { @@ -691,7 +965,7 @@ "10" ] }, - "execution_count": null, + "execution_count": 35, "metadata": {}, "output_type": "execute_result" } @@ -702,28 +976,25 @@ ] }, { - "cell_type": "code", - "execution_count": null, + "cell_type": "markdown", "metadata": {}, - "outputs": [], "source": [ - "def print_stats(outp, inp): print (outp.mean().item(),outp.std().item())\n", - "for i in range(4): m.layers[i].hook = print_stats" + "Now we can try adding a hook. Note that we've only left room for one hook in `Module`; you could make it a list, or else use something like `Pipeline` to run a few as a single function." ] }, { "cell_type": "code", - "execution_count": null, + "execution_count": 36, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ - "0.41993722319602966 0.6984175443649292\n", - "0.31132981181144714 0.5268176794052124\n", - "0.30335918068885803 0.547913670539856\n", - "0.32568952441215515 0.5254442095756531\n" + "0.5239089727401733 0.8776043057441711\n", + "0.43470510840415955 0.8347987532615662\n", + "0.4357188045978546 0.7621666193008423\n", + "0.46562111377716064 0.7416611313819885\n" ] }, { @@ -732,12 +1003,15 @@ "torch.Size([128, 10])" ] }, - "execution_count": null, + "execution_count": 36, "metadata": {}, "output_type": "execute_result" } ], "source": [ + "def print_stats(outp, inp): print (outp.mean().item(),outp.std().item())\n", + "for i in range(4): m.layers[i].hook = print_stats\n", + "\n", "r = m(xbt)\n", "r.shape" ] @@ -749,9 +1023,16 @@ "## Loss" ] }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "We have data and model. Now we need a loss function. We've already seen how to define \"negative log likelihood\":" + ] + }, { "cell_type": "code", - "execution_count": null, + "execution_count": 37, "metadata": {}, "outputs": [], "source": [ @@ -762,50 +1043,50 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "And check the kind of result it gives (since our model was trained for two epoch, this should be pretty low):" + "Well actually, there's no `log` here, since we're using the same definition as PyTorch. That means we need to put the `log` together with `softmax`:" ] }, { "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [ - "def log_softmax(x): return (x.exp()/(x.exp().sum(-1,keepdim=True))).log()" - ] - }, - { - "cell_type": "code", - "execution_count": null, + "execution_count": 38, "metadata": {}, "outputs": [ { "data": { "text/plain": [ - "tensor(-2.7753, grad_fn=)" + "tensor(-1.2790, grad_fn=)" ] }, - "execution_count": null, + "execution_count": 38, "metadata": {}, "output_type": "execute_result" } ], "source": [ + "def log_softmax(x): return (x.exp()/(x.exp().sum(-1,keepdim=True))).log()\n", + "\n", "sm = log_softmax(r); sm[0][0]" ] }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Combining these together give us our cross entropy loss:" + ] + }, { "cell_type": "code", - "execution_count": null, + "execution_count": 39, "metadata": {}, "outputs": [ { "data": { "text/plain": [ - "tensor(2.5293, grad_fn=)" + "tensor(2.5666, grad_fn=)" ] }, - "execution_count": null, + "execution_count": 39, "metadata": {}, "output_type": "execute_result" } @@ -823,21 +1104,21 @@ "\n", "$$\\log \\left ( \\frac{a}{b} \\right ) = \\log(a) - \\log(b)$$ \n", "\n", - "gives a simplification when we compute the log softmax, which was previously defined as `(x.exp()/(x.exp().sum(-1,keepdim=True))).log()`" + "gives a simplification when we compute the log softmax, which was previously defined as `(x.exp()/(x.exp().sum(-1))).log()`:" ] }, { "cell_type": "code", - "execution_count": null, + "execution_count": 40, "metadata": {}, "outputs": [ { "data": { "text/plain": [ - "tensor(-2.7753, grad_fn=)" + "tensor(-1.2790, grad_fn=)" ] }, - "execution_count": null, + "execution_count": 40, "metadata": {}, "output_type": "execute_result" } @@ -863,16 +1144,16 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 41, "metadata": {}, "outputs": [ { "data": { "text/plain": [ - "tensor(False)" + "tensor(True)" ] }, - "execution_count": null, + "execution_count": 41, "metadata": {}, "output_type": "execute_result" } @@ -884,33 +1165,33 @@ ] }, { - "cell_type": "code", - "execution_count": null, + "cell_type": "markdown", "metadata": {}, - "outputs": [], "source": [ - "def logsumexp(x):\n", - " m = x.max(-1)[0]\n", - " return m + (x-m[:,None]).exp().sum(-1).log()" + "We'll put that into a function:" ] }, { "cell_type": "code", - "execution_count": null, + "execution_count": 42, "metadata": {}, "outputs": [ { "data": { "text/plain": [ - "tensor(2.3158, grad_fn=)" + "tensor(3.9784, grad_fn=)" ] }, - "execution_count": null, + "execution_count": 42, "metadata": {}, "output_type": "execute_result" } ], "source": [ + "def logsumexp(x):\n", + " m = x.max(-1)[0]\n", + " return m + (x-m[:,None]).exp().sum(-1).log()\n", + "\n", "logsumexp(r)[0]" ] }, @@ -918,30 +1199,37 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "So we can use it for our `log_softmax` function." + "...so we can use it for our `log_softmax` function:" ] }, { "cell_type": "code", - "execution_count": null, + "execution_count": 43, "metadata": {}, "outputs": [], "source": [ "def log_softmax(x): return x - x.logsumexp(-1,keepdim=True)" ] }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "...which gives the same result as before:" + ] + }, { "cell_type": "code", - "execution_count": null, + "execution_count": 44, "metadata": {}, "outputs": [ { "data": { "text/plain": [ - "tensor(-2.7753, grad_fn=)" + "tensor(-1.2790, grad_fn=)" ] }, - "execution_count": null, + "execution_count": 44, "metadata": {}, "output_type": "execute_result" } @@ -950,9 +1238,16 @@ "sm = log_softmax(r); sm[0][0]" ] }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "We'll use these to create `cross_entropy`:" + ] + }, { "cell_type": "code", - "execution_count": null, + "execution_count": 45, "metadata": {}, "outputs": [], "source": [ @@ -966,9 +1261,16 @@ "## Learner" ] }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "We have data, model, and loss function; only one thing left before we can fit a model, and that's an optimizer! Here's SGD:" + ] + }, { "cell_type": "code", - "execution_count": null, + "execution_count": 46, "metadata": {}, "outputs": [], "source": [ @@ -980,31 +1282,40 @@ " p.grad.data.zero_()" ] }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "As we've seen in this book, life is easier with a `Learner`, which needs to know our training and validation sets, which means we need `DataLoaders` to store them. We don't need any other functionality--just a place to store them and access them:" + ] + }, { "cell_type": "code", - "execution_count": null, + "execution_count": 47, "metadata": {}, "outputs": [], "source": [ "class DataLoaders:\n", - " def __init__(self, *dls): self.train,self.valid = dls" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [ + " def __init__(self, *dls): self.train,self.valid = dls\n", + "\n", "dls = DataLoaders(train_dl,valid_dl)" ] }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Now we're ready to create our `Learner` class, which you can see in <>." + ] + }, { "cell_type": "code", - "execution_count": null, + "execution_count": 57, "metadata": {}, "outputs": [], "source": [ + "#id class_learner\n", + "#caption The Learner class\n", "class Learner:\n", " def __init__(self, model, dls, loss_func, lr, cbs, opt_func=SGD):\n", " store_attr(self, 'model,dls,loss_func,lr,cbs,opt_func')\n", @@ -1043,18 +1354,83 @@ " for cb in self.cbs: getattr(cb,name,noop)()" ] }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "This is our largest class we've created in the book, but each method is quite small, so by looking at each in turn we'll be able to following what's going on.\n", + "\n", + "The main method we'll be calling is `fit`. This loops with:\n", + "\n", + " for self.epoch in range(n_epochs)\n", + "\n", + "...and at each epoch calls `self.one_epoch` for each of `train=True` and then `train=False`. Then `self.one_epoch` calls `self.one_batch` for each batch in `dls.train` or `dls.valid` as appropriate (after wrapping the `DataLoader` in `fastprogress.progress_bar`. Finally, `self.one_batch` follows the usual set of steps to fit one mini-batch that we've seen through this book.\n", + "\n", + "Before and after each step, `Learner` calls `self(...)`, which calls `__call__` (which is standard Python functionality). `__call__` uses `getattr(cb,name)` on each callback in `self.cbs`, which is a Python builtin function which returns the attribute (a method, in this case) with the requested name. So, for instance, `self('before_fit')` will call `cb.before_fit()` for each callback where that method is defined.\n", + "\n", + "So we can see that `Learner` is really just using our standard training loop, except that it's also calling callbacks at appropriate times. So let's define some callbacks!" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Callbacks" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "In `Learner.__init__` we have:\n", + "\n", + " for cb in cbs: cb.learner = self\n", + "\n", + "In other words, every callback knows what learner it is used in. This is critical, since otherwise a callback can't get information from the learner, or change things in the learner. Since getting information from the learner is so common, we make that easier by definined `Callback` as a subclass of `GetAttr`, with a default attribute of `learner`. `GetAttr` is a class in fastai which implements Python's standard `__getattr__` and `__dir__` methods for you, such such any time you try to access an attribute that doesn't exist, it passes the request along to whatever you have defined as `_default`." + ] + }, { "cell_type": "code", - "execution_count": null, + "execution_count": 58, "metadata": {}, "outputs": [], "source": [ "class Callback(GetAttr): _default='learner'" ] }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "For instance, we want to move all model parameters to the GPU automatically at the start of `fit`. We could do this by defining `before_fit` as `self.learner.model.cuda()`; however, because `learner` is the default attribute, and we have `SetupLearnerCB` inherit from `Callback` (which inherits from `GetAttr`), we can remove the `.learner` and just call `self.model.cuda()`:" + ] + }, { "cell_type": "code", - "execution_count": null, + "execution_count": 59, + "metadata": {}, + "outputs": [], + "source": [ + "class SetupLearnerCB(Callback):\n", + " def before_batch(self):\n", + " xb,yb = to_device(self.batch)\n", + " self.learner.batch = tfm_x(xb),yb\n", + "\n", + " def before_fit(self): self.model.cuda()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "In `SetupLearnerCB` we also move each mini-batch to the GPU, by calling `to_device(self.batch)` (we could also have used the longer `to_device(self.learner.batch)`. Note however that in the line `self.learner.batch = tfm_x(xb),yb` we can't remove `.learner`, because here we're *setting* the attribute, not getting it.\n", + "\n", + "Before we try our `Learner` out, let's create a callback to track and print progress, otherwise we won't really know if it's working properly:" + ] + }, + { + "cell_type": "code", + "execution_count": 60, "metadata": {}, "outputs": [], "source": [ @@ -1076,40 +1452,15 @@ ] }, { - "cell_type": "code", - "execution_count": null, + "cell_type": "markdown", "metadata": {}, - "outputs": [], "source": [ - "class SetupLearnerCB(Callback):\n", - " def before_batch(self):\n", - " xb,yb = to_device(self.batch)\n", - " self.learner.batch = tfm_x(xb),yb\n", - "\n", - " def before_fit(self): self.model.cuda()" + "Now we're ready to use our `Learner` for the first time!" ] }, { "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [ - "cbs = [SetupLearnerCB(),TrackResults()]" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [ - "learn = Learner(simple_cnn(), dls, cross_entropy, lr=0.1, cbs=cbs)" - ] - }, - { - "cell_type": "code", - "execution_count": null, + "execution_count": 61, "metadata": {}, "outputs": [ { @@ -1126,7 +1477,7 @@ "name": "stdout", "output_type": "stream", "text": [ - "0 True 2.1446147873983525 0.21987538282817615\n" + "0 True 2.1275552130636814 0.2314922378287042\n" ] }, { @@ -1143,14 +1494,23 @@ "name": "stdout", "output_type": "stream", "text": [ - "0 False 2.0508458150875795 0.26343949044585985\n" + "0 False 1.9942575636942674 0.2991082802547771\n" ] } ], "source": [ + "cbs = [SetupLearnerCB(),TrackResults()]\n", + "learn = Learner(simple_cnn(), dls, cross_entropy, lr=0.1, cbs=cbs)\n", "learn.fit(1)" ] }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "It's quite amazing to realize that we can implement all the key ideas from fastai's `Learner` in so little code!" + ] + }, { "cell_type": "markdown", "metadata": {}, @@ -1158,9 +1518,16 @@ "## Annealing" ] }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "If we're going to get good results, we'll want an LR Finder and one-cycle training. These are both *annealing* callbacks--that is, they are gradually changing hyperparameters as we train. Here's `LRFinder`:" + ] + }, { "cell_type": "code", - "execution_count": null, + "execution_count": 62, "metadata": {}, "outputs": [], "source": [ @@ -1181,26 +1548,15 @@ ] }, { - "cell_type": "code", - "execution_count": null, + "cell_type": "markdown", "metadata": {}, - "outputs": [], "source": [ - "lrfind = LRFinder()" + "This shows how we're using `CancelFitException`, which is itself an empty class, only used to signify the type of exception. You can see in `Learner` that this exception is caught. (You should add and test `CancelBatchException`, `CancelEpochException`, etc yourself.) Let's try it out, by adding it to our list of callbacks:" ] }, { "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [ - "learn = Learner(simple_cnn(), dls, cross_entropy, lr=0.1, cbs=cbs+[lrfind])" - ] - }, - { - "cell_type": "code", - "execution_count": null, + "execution_count": 63, "metadata": {}, "outputs": [ { @@ -1217,7 +1573,7 @@ "name": "stdout", "output_type": "stream", "text": [ - "0 True 2.490109584565424 0.10507973386841271" + "0 True 2.6336045582954903 0.11014890695955222\n" ] }, { @@ -1234,7 +1590,7 @@ "name": "stdout", "output_type": "stream", "text": [ - "0 False 2.332222830414013 0.09859872611464968" + "0 False 2.230653363853503 0.18318471337579617\n" ] }, { @@ -1254,8 +1610,8 @@ " background: #F44336;\n", " }\n", " \n", - " \n", - " 18.92% [14/74 00:02<00:12]\n", + " \n", + " 16.22% [12/74 00:02<00:12]\n", " \n", " " ], @@ -1268,9 +1624,18 @@ } ], "source": [ + "lrfind = LRFinder()\n", + "learn = Learner(simple_cnn(), dls, cross_entropy, lr=0.1, cbs=cbs+[lrfind])\n", "learn.fit(2)" ] }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "...and have a look at the results:" + ] + }, { "cell_type": "code", "execution_count": null, @@ -1294,6 +1659,13 @@ "plt.xscale('log')" ] }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Now we can define our `OneCycle` training callback:" + ] + }, { "cell_type": "code", "execution_count": null, @@ -1322,12 +1694,10 @@ ] }, { - "cell_type": "code", - "execution_count": null, + "cell_type": "markdown", "metadata": {}, - "outputs": [], "source": [ - "onecyc = OneCycle(0.1)" + "We'll try an LR of `0.1`:" ] }, { @@ -1336,291 +1706,34 @@ "metadata": {}, "outputs": [], "source": [ + "onecyc = OneCycle(0.1)\n", "learn = Learner(simple_cnn(), dls, cross_entropy, lr=0.1, cbs=cbs+[onecyc])" ] }, { - "cell_type": "code", - "execution_count": null, + "cell_type": "markdown", "metadata": {}, - "outputs": [ - { - "data": { - "text/html": [], - "text/plain": [ - "" - ] - }, - "metadata": {}, - "output_type": "display_data" - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "0 True 2.2302985812255782 0.17985003696272045\n" - ] - }, - { - "data": { - "text/html": [], - "text/plain": [ - "" - ] - }, - "metadata": {}, - "output_type": "display_data" - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "0 False 2.197772939888535 0.1819108280254777\n" - ] - }, - { - "data": { - "text/html": [], - "text/plain": [ - "" - ] - }, - "metadata": {}, - "output_type": "display_data" - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "1 True 2.0975320783609672 0.24215862287464357\n" - ] - }, - { - "data": { - "text/html": [], - "text/plain": [ - "" - ] - }, - "metadata": {}, - "output_type": "display_data" - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "1 False 1.9934868879378982 0.3026751592356688\n" - ] - }, - { - "data": { - "text/html": [], - "text/plain": [ - "" - ] - }, - "metadata": {}, - "output_type": "display_data" - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2 True 1.9510114006890906 0.3118597528778118\n" - ] - }, - { - "data": { - "text/html": [], - "text/plain": [ - "" - ] - }, - "metadata": {}, - "output_type": "display_data" - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2 False 1.8667540804140128 0.35337579617834397\n" - ] - }, - { - "data": { - "text/html": [], - "text/plain": [ - "" - ] - }, - "metadata": {}, - "output_type": "display_data" - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "3 True 1.8408451674543247 0.3651916781075087\n" - ] - }, - { - "data": { - "text/html": [], - "text/plain": [ - "" - ] - }, - "metadata": {}, - "output_type": "display_data" - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "3 False 1.7804740993232484 0.38471337579617837\n" - ] - }, - { - "data": { - "text/html": [], - "text/plain": [ - "" - ] - }, - "metadata": {}, - "output_type": "display_data" - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "4 True 1.7385770342697222 0.40162635970007393\n" - ] - }, - { - "data": { - "text/html": [], - "text/plain": [ - "" - ] - }, - "metadata": {}, - "output_type": "display_data" - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "4 False 1.7134963425557326 0.4206369426751592\n" - ] - }, - { - "data": { - "text/html": [], - "text/plain": [ - "" - ] - }, - "metadata": {}, - "output_type": "display_data" - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "5 True 1.6633978104538494 0.4345759847924807\n" - ] - }, - { - "data": { - "text/html": [], - "text/plain": [ - "" - ] - }, - "metadata": {}, - "output_type": "display_data" - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "5 False 1.7293920431926753 0.39923566878980893\n" - ] - }, - { - "data": { - "text/html": [], - "text/plain": [ - "" - ] - }, - "metadata": {}, - "output_type": "display_data" - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "6 True 1.5818110619191572 0.46477980779385364\n" - ] - }, - { - "data": { - "text/html": [], - "text/plain": [ - "" - ] - }, - "metadata": {}, - "output_type": "display_data" - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "6 False 1.6024532245222929 0.4565605095541401\n" - ] - }, - { - "data": { - "text/html": [], - "text/plain": [ - "" - ] - }, - "metadata": {}, - "output_type": "display_data" - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "7 True 1.5281916030269829 0.4891752032949625\n" - ] - }, - { - "data": { - "text/html": [], - "text/plain": [ - "" - ] - }, - "metadata": {}, - "output_type": "display_data" - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "7 False 1.5787282294984077 0.47312101910828025\n" - ] - } - ], "source": [ + "Let's fit for a while and see how it looks (we won't show all the output in the book--try it in the notebook to see the results):" + ] + }, + { + "cell_type": "code", + "execution_count": 64, + "metadata": {}, + "outputs": [], + "source": [ + "#hide_output\n", "learn.fit(8)" ] }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Finally, we'll check that the learning rate followed the schedule we defined (as you see, we're not using cosine annealing here)." + ] + }, { "cell_type": "code", "execution_count": null, @@ -1693,7 +1806,8 @@ "1. What is `store_attr`?\n", "1. What is the purpose of `TrackResults.before_epoch`?\n", "1. What does `model.cuda()` do? How does it work?\n", - "1. Why do we need to check `model.training` in `LRFinder` and `OneCycle`?" + "1. Why do we need to check `model.training` in `LRFinder` and `OneCycle`?\n", + "1. Use cosine annealing in `OneCycle`." ] }, { @@ -1731,6 +1845,31 @@ "display_name": "Python 3", "language": "python", "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.7.5" + }, + "toc": { + "base_numbering": 1, + "nav_menu": {}, + "number_sections": false, + "sideBar": true, + "skip_h1_title": true, + "title_cell": "Table of Contents", + "title_sidebar": "Contents", + "toc_cell": false, + "toc_position": {}, + "toc_section_display": true, + "toc_window_display": false } }, "nbformat": 4,