markdown
stringlengths 0
1.02M
| code
stringlengths 0
832k
| output
stringlengths 0
1.02M
| license
stringlengths 3
36
| path
stringlengths 6
265
| repo_name
stringlengths 6
127
|
|---|---|---|---|---|---|
This is a bit more complex already. Proceeding from left to right, we first have the state `¬ quote ∧ ¬ tag`, which is our "standard" state for text. If we encounter a `'<'`, we again switch to the "tagged" state `¬ quote ∧ tag`. In this state, however (and only in this state), if we encounter a quotation mark, we switch to the "quotation" state `quote ∧ tag`, in which we remain until we see another quotation mark indicating the end of the string – and then continue in the "tagged" state `¬ quote ∧ tag` until we see the end of the string. Things get even more complicated as HTML allows both single and double quotation characters. Here's a revised implementation of `remove_html_markup()` that takes the above states into account: | def remove_html_markup(s):
tag = False
quote = False
out = ""
for c in s:
if c == '<' and not quote:
tag = True
elif c == '>' and not quote:
tag = False
elif c == '"' or c == "'" and tag:
quote = not quote
elif not tag:
out = out + c
return out | _____no_output_____ | MIT | Intro_Debugging.ipynb | doscac/ReducingCode |
Now, our previous input works well: | remove_html_markup('<input type="text" value="<your name>">') | _____no_output_____ | MIT | Intro_Debugging.ipynb | doscac/ReducingCode |
and our earlier tests also pass: | assert remove_html_markup("Here's some <strong>strong argument</strong>.") == \
"Here's some strong argument."
assert remove_html_markup('<input type="text" value="<your name>">') == "" | _____no_output_____ | MIT | Intro_Debugging.ipynb | doscac/ReducingCode |
However, the above code still has a bug. In two of these inputs, HTML markup is still not properly stripped:```htmlfoo"foo""foo"foo```Can you guess which ones these are? Again, a simple assertion will reveal the culprits: | with ExpectError():
assert remove_html_markup('<b>foo</b>') == 'foo'
with ExpectError():
assert remove_html_markup('<b>"foo"</b>') == '"foo"'
with ExpectError():
assert remove_html_markup('"<b>foo</b>"') == '"foo"'
with ExpectError():
assert remove_html_markup('<"b">foo</"b">') == 'foo' | _____no_output_____ | MIT | Intro_Debugging.ipynb | doscac/ReducingCode |
So, unfortunately, we're not done yet – our function still has errors. The Devil's Guide to DebuggingLet us now discuss a couple of methods that do _not_ work well for debugging. (These "devil's suggestions" are adapted from the 1993 book "Code Complete" from Steve McConnell.) Printf DebuggingWhen I was a student, never got any formal training in debugging, so I had to figure this out for myself. What I learned was how to use _debugging output_; in Python, this would be the `print()` function. For instance, I would go and scatter `print()` calls everywhere: | def remove_html_markup_with_print(s):
tag = False
quote = False
out = ""
for c in s:
print("c =", repr(c), "tag =", tag, "quote =", quote)
if c == '<' and not quote:
tag = True
elif c == '>' and not quote:
tag = False
elif c == '"' or c == "'" and tag:
quote = not quote
elif not tag:
out = out + c
return out | _____no_output_____ | MIT | Intro_Debugging.ipynb | doscac/ReducingCode |
This way of inspecting executions is commonly called "Printf debugging", after the C `printf()` function. Then, running this would allow me to see what's going on in my code: | remove_html_markup_with_print('<b>"foo"</b>') | c = '<' tag = False quote = False
c = 'b' tag = True quote = False
c = '>' tag = True quote = False
c = '"' tag = False quote = False
c = 'f' tag = False quote = True
c = 'o' tag = False quote = True
c = 'o' tag = False quote = True
c = '"' tag = False quote = True
c = '<' tag = False quote = False
c = '/' tag = True quote = False
c = 'b' tag = True quote = False
c = '>' tag = True quote = False
| MIT | Intro_Debugging.ipynb | doscac/ReducingCode |
Yes, one sees what is going on – but this is horribly inefficient! Think of a 1,000-character input – you'd have to go through 2,000 lines of logs. It may help you, but it's a total time waster. Plus, you have to enter these statements, remove them again... it's a maintenance nightmare. (You may even forget printf's in your code, creating a security problem: Mac OS X versions 10.7 to 10.7.3 would log the password in clear because someone had forgotten to turn off debugging output.) Debugging into Existence I would also try to _debug the program into existence._ Just change things until they work. Let me see: If I remove the conditions "and not quote" from the program, it would actually work again: | def remove_html_markup_without_quotes(s):
tag = False
quote = False
out = ""
for c in s:
if c == '<': # and not quote:
tag = True
elif c == '>': # and not quote:
tag = False
elif c == '"' or c == "'" and tag:
quote = not quote
elif not tag:
out = out + c
return out
assert remove_html_markup_without_quotes('<"b">foo</"b">') == 'foo' | _____no_output_____ | MIT | Intro_Debugging.ipynb | doscac/ReducingCode |
Cool! Unfortunately, the function still fails on the other input: | with ExpectError():
assert remove_html_markup_without_quotes('<b>"foo"</b>') == '"foo"' | Traceback (most recent call last):
File "<ipython-input-28-1d8954a52bcf>", line 2, in <module>
assert remove_html_markup_without_quotes('<b>"foo"</b>') == '"foo"'
AssertionError (expected)
| MIT | Intro_Debugging.ipynb | doscac/ReducingCode |
So, maybe we can change things again, such that both work? And maybe the other tests we had earlier won't fail? Let's just continue to change things randomly again and again and again. Oh, and of course, I would never back up earlier versions such that I would be able to keep track of what has changed and when. Use the Most Obvious Fix My favorite: Use the most obvious fix. This means that you're fixing the symptom, not the problem. In our case, this would be something like: | def remove_html_markup_fixed(s):
if s == '<b>"foo"</b>':
return '"foo"'
... | _____no_output_____ | MIT | Intro_Debugging.ipynb | doscac/ReducingCode |
Miracle! Our earlier failing assertion now works! Now we can do the same for the other failing test, too, and we're done.(Rumor has it that some programmers use this technique to get their tests to pass...) Things to do InsteadAs with any devil's guide, you get an idea of how to do things by doing the _opposite._ What this means is:1. Understand the code2. Fix the problem, not the symptom3. Proceed systematicallywhich is what we will apply for the rest of this chapter. From Defect to FailureTo understand how to systematically debug a program, we first have to understand how failures come to be. The typical debugging situation looks like this. We have a program (execution), taking some input and producing some output. The output is in *error* (✘), meaning an unwanted and unintended deviation from what is correct, right, or true.The input, in contrast, is assumed to be correct (✔). (Otherwise, we wouldn't search for the bug in our program, but in whatever produced its input.) | # ignore
def execution_diagram(show_steps=True, variables=[],
steps=3, error_step=666,
until=666, fault_path=[]):
dot = graph()
dot.node('input', shape='none', fillcolor='white', label=f"Input {PASS}",
fontcolor=PASS_COLOR)
last_outgoing_states = ['input']
for step in range(1, min(steps + 1, until)):
if step == error_step:
step_label = f'Step {step} {FAIL}'
step_color = FAIL_COLOR
else:
step_label = f'Step {step}'
step_color = None
if step >= error_step:
state_label = f'State {step} {FAIL}'
state_color = FAIL_COLOR
else:
state_label = f'State {step} {PASS}'
state_color = PASS_COLOR
state_name = f's{step}'
outgoing_states = []
incoming_states = []
if not variables:
dot.node(name=state_name, shape='box',
label=state_label, color=state_color,
fontcolor=state_color)
else:
var_labels = []
for v in variables:
vpath = f's{step}:{v}'
if vpath in fault_path:
var_label = f'<{v}>{v} ✘'
outgoing_states.append(vpath)
incoming_states.append(vpath)
else:
var_label = f'<{v}>{v}'
var_labels.append(var_label)
record_string = " | ".join(var_labels)
dot.node(name=state_name, shape='record',
label=nohtml(record_string), color=state_color,
fontcolor=state_color)
if not outgoing_states:
outgoing_states = [state_name]
if not incoming_states:
incoming_states = [state_name]
for outgoing_state in last_outgoing_states:
for incoming_state in incoming_states:
if show_steps:
dot.edge(outgoing_state, incoming_state,
label=step_label, fontcolor=step_color)
else:
dot.edge(outgoing_state, incoming_state)
last_outgoing_states = outgoing_states
if until > steps + 1:
# Show output
if error_step > steps:
dot.node('output', shape='none', fillcolor='white',
label=f"Output {PASS}", fontcolor=PASS_COLOR)
else:
dot.node('output', shape='none', fillcolor='white',
label=f"Output {FAIL}", fontcolor=FAIL_COLOR)
for outgoing_state in last_outgoing_states:
label = "Execution" if steps == 0 else None
dot.edge(outgoing_state, 'output', label=label)
display(dot)
# ignore
execution_diagram(show_steps=False, steps=0, error_step=0) | _____no_output_____ | MIT | Intro_Debugging.ipynb | doscac/ReducingCode |
This situation we see above is what we call a *failure*: An externally visible _error_ in the program behavior, with the error again being an unwanted and unintended deviation from what is correct, right, or true. How does this failure come to be? The execution we see above breaks down into several program _states_, one after the other. | # ignore
for until in range(1, 6):
execution_diagram(show_steps=False, until=until, error_step=2) | _____no_output_____ | MIT | Intro_Debugging.ipynb | doscac/ReducingCode |
Initially, the program state is still correct (✔). However, at some point in the execution, the state gets an _error_, also known as a *fault*. This fault – again an unwanted and unintended deviation from what is correct, right, or true – then propagates along the execution, until it becomes externally visible as a _failure_.(In reality, there are many, many more states than just this, but these would not fit in a diagram.) How does a fault come to be? Each of these program states is produced by a _step_ in the program code. These steps take a state as input and produce another state as output. Technically speaking, the program inputs and outputs are also parts of the program state, so the input flows into the first step, and the output is the state produced by the last step. | # ignore
for until in range(1, 6):
execution_diagram(show_steps=True, until=until, error_step=2) | _____no_output_____ | MIT | Intro_Debugging.ipynb | doscac/ReducingCode |
Now, in the diagram above, Step 2 gets a _correct_ state as input and produces a _faulty_ state as output. The produced fault then propagates across more steps to finally become visible as a _failure_. The goal of debugging thus is to _search_ for the step in which the state first becomes faulty. The _code_ associated with this step is again an error – an unwanted and unintended deviation from what is correct, right, or true – and is called a _defect_. This is what we have to find – and to fix. Sounds easy, right? Unfortunately, things are not that easy, and that has something to do with the program state. Let us assume our state consists of three variables, `v1` to `v3`, and that Step 2 produces a fault in `v2`. This fault then propagates to the output: | # ignore
for until in range(1, 6):
execution_diagram(show_steps=True, variables=['v1', 'v2', 'v3'],
error_step=2,
until=until, fault_path=['s2:v2', 's3:v2']) | _____no_output_____ | MIT | Intro_Debugging.ipynb | doscac/ReducingCode |
The way these faults propagate is called a *cause-effect chain*:* The _defect_ in the code _causes_ a fault in the state when executed.* This _fault_ in the state then _propagates_ through further execution steps...* ... until it becomes visible as a _failure_. Since the code was originally written by a human, any defect can be related to some original _mistake_ the programmer made. This gives us a number of terms that all are more precise than the general "error" or the colloquial "bug":* A _mistake_ is a human act or decision resulting in an error.* A _defect_ is an error in the program code. Also called *bug*.* A _fault_ is an error in the program state. Also called *infection*.* A _failure_ is an externally visible error in the program behavior. Also called *malfunction*.The cause-effect chain of events is thus* Mistake → Defect → Fault → ... → Fault → FailureNote that not every defect also causes a failure, which is despite all testing, there can still be defects in the code looming around until the right conditions are met to trigger them. On the other hand, though, _every failure can be traced back to the defect that causes it_. Our job is to break the cause-effect chain. From Failure to DefectTo find a defect from a failure, we _trace back_ the faults along their _propagation_ – that is, we find out which faults in the earlier state have caused the later faults. We start from the very end of the execution and then gradually progress backwards in time, examining fault after fault until we find a _transition_ from a correct state to a faulty state – that is, astep in which a correct state comes in and a faulty state comes out. At this point, we have found the origin of the failure – and the defect that causes it. What sounds like a straight-forward strategy, unfortunately, doesn't always work this way in practice. That is because of the following problems of debugging:* First, program states are actually _large_, encompassing dozens to thousands of variables, possibly even more. If you have to search all of these manually and check them for faults, you will spend a lot of time for a single state.* Second, you do not always know _whether a state is correct or not._ While most programs have some form of specification for their inputs and outputs, these do not necessarily exist for intermediate results. If one had a specification that could check each state for correctness (possibly even automatically), debugging would be trivial. Unfortunately, it is not, and that's partly due to the lack of specifications.* Third, executions typically do not come in a handful of steps, as in the diagrams above; instead, they can easily encompass _thousands to millions of steps._ This means that you will have to examine not just one state, but several, making the problem much worse.To make your search efficient, you thus have to _focus_ your search – starting with most likely causes and gradually progressing to the less probable causes. This is what we call a _debugging strategy_. The Scientific MethodNow that we know how failures come to be, let's look into how to systematically find their causes. What we need is a _strategy_ that helps us search for how and when the failure comes to be. For this, we use a process called the *scientific method*. When we are debugging a program, we are trying to find the causes of a given effect – very much like natural scientists try to understand why things in nature are as they are and how they come to be. Over thousands of years, scientists have conducted _observations_ and _experiments_ to come to an understanding of how our world works. The process by which experimental scientists operate has been coined "The scientific method". This is how it works: 1. Formulate a _question_, as in "Why does this apple fall down?".2. Invent a _hypothesis_ based on knowledge obtained while formulating the question, that may explain the observed behavior. 3. Determining the logical consequences of the hypothesis, formulate a _prediction_ that can _support_ or _refute_ the hypothesis. Ideally, the prediction would distinguish the hypothesis from likely alternatives.4. _Test_ the prediction (and thus the hypothesis) in an _experiment_. If the prediction holds, confidence in the hypothesis increases; otherwise, it decreases.5. Repeat Steps 2–4 until there are no discrepancies between hypothesis and predictions and/or observations. At this point, your hypothesis may be named a *theory* – that is, a predictive and comprehensive description of some aspect of the natural world. The gravitational theory, for instance, predicts very well how the moon revolves around the earth, and how the earth revolves around the sun. Our debugging problems are of a slightly lesser scale – we'd like a theory of how our failure came to be – but the process is pretty much the same. | # ignore
dot = graph()
dot.node('Hypothesis')
dot.node('Observation')
dot.node('Prediction')
dot.node('Experiment')
dot.edge('Hypothesis', 'Observation',
label="<Hypothesis<BR/>is <I>supported:</I><BR/>Refine it>",
dir='back')
dot.edge('Hypothesis', 'Prediction')
dot.node('Problem Report', shape='none', fillcolor='white')
dot.edge('Problem Report', 'Hypothesis')
dot.node('Code', shape='none', fillcolor='white')
dot.edge('Code', 'Hypothesis')
dot.node('Runs', shape='none', fillcolor='white')
dot.edge('Runs', 'Hypothesis')
dot.node('More Runs', shape='none', fillcolor='white')
dot.edge('More Runs', 'Hypothesis')
dot.edge('Prediction', 'Experiment')
dot.edge('Experiment', 'Observation')
dot.edge('Observation', 'Hypothesis',
label="<Hypothesis<BR/>is <I>rejected:</I><BR/>Seek alternative>")
# ignore
display(dot) | _____no_output_____ | MIT | Intro_Debugging.ipynb | doscac/ReducingCode |
In debugging, we proceed the very same way – indeed, we are treating bugs as if they were natural phenomena. This analogy may sound far-fetched, as programs are anything but natural. Nature, by definition, is not under our control. But bugs are _out of our control just as well._ Hence, the analogy is not that far-fetched – and we can apply the same techniques for debugging. Finding a Hypothesis Let us apply the scientific method to our Python program which removes HTML tags. First of all, let us recall the problem – `remove_html_markup()` works for some inputs, but fails on others. | for i, html in enumerate(['<b>foo</b>',
'<b>"foo"</b>',
'"<b>foo</b>"',
'<"b">foo</"b">']):
result = remove_html_markup(html)
print("%-2d %-15s %s" % (i + 1, html, result)) | 1 <b>foo</b> foo
2 <b>"foo"</b> foo
3 "<b>foo</b>" <b>foo</b>
4 <"b">foo</"b"> foo
| MIT | Intro_Debugging.ipynb | doscac/ReducingCode |
Input 1 and 4 work as expected, the others do not. We can write these down in a table, such that we can always look back at our previous results:|Input|Expectation|Output|Outcome||-----|-----------|------|-------||`foo`|`foo`|`foo`|✔||`"foo"`|`"foo"`|`foo`|✘||`"foo"`|`"foo"`|`foo`|✘||`foo`|`foo`|`foo`|✔| | quiz("From the difference between success and failure,"
" we can already devise some observations about "
" what's wrong with the output."
" Which of these can we turn into general hypotheses?",
["Double quotes are stripped from the tagged input.",
"Tags in double quotes are not stripped.",
"The tag '<b>' is always stripped from the input.",
"Four-letter words are stripped."], [298 % 33, 1234 % 616]) | _____no_output_____ | MIT | Intro_Debugging.ipynb | doscac/ReducingCode |
Testing a HypothesisThe hypotheses that remain are:1. Double quotes are stripped from the tagged input.2. Tags in double quotes are not stripped. These may be two separate issues, but chances are they are tied to each other. Let's focus on 1., because it is simpler. Does it hold for all inputs, even untagged ones? Our hypothesis becomes1. Double quotes are stripped from the ~~tagged~~ input. Let's devise an experiment to validate this. If we feed the string```html"foo"```(including the double quotes) into `remove_html_markup()`, we should obtain```html"foo"```as result – that is, the output should be the unchanged input. However, if our hypothesis 1. is correct, we should obtain```htmlfoo```as result – that is, "Double quotes are stripped from the input" as predicted by the hypothesis. We can very easily test this hypothesis: | remove_html_markup('"foo"') | _____no_output_____ | MIT | Intro_Debugging.ipynb | doscac/ReducingCode |
Our hypothesis is confirmed! We can add this to our list of observations. |Input|Expectation|Output|Outcome||-----|-----------|------|-------||`foo`|`foo`|`foo`|✔||`"foo"`|`"foo"`|`foo`|✘||`"foo"`|`"foo"`|`foo`|✘||`foo`|`foo`|`foo`|✔||`"foo"`|`"foo"`|`foo`|✘| You can try out the hypothesis with more inputs – and it remains valid. Any non-markup input that contains double quotes will have these stripped. Where does that quote-stripping come from? This is where we need to explore the cause-effect chain. The only place in `remove_html_markup()` where quotes are handled is this line:```pythonelif c == '"' or c == "'" and tag: quote = not quote```So, quotes should be removed only if `tag` is set. However, `tag` can be set only if the input contains a markup tag, which is not the case for a simple input like `"foo"`. Hence, what we observe is actually _impossible._ Yet, it happens. Refining a HypothesisDebugging is a game of falsifying assumptions. You assume the code works – it doesn't. You assume the `tag` flag cannot be set – yet it may be. What do we do? Again, we create a hypothesis:1. The error is due to `tag` being set. How do we know whether tag is being set? Let me introduce one of the most powerful debugging tools ever invented, the `assert` statement. The statement```pythonassert cond```evaluates the given condition `cond` and* if it holds: proceed as usual* if `cond` does not hold: throw an exceptionAn `assert` statement _encodes our assumptions_ and as such, should never fail. If it does, well, then something is wrong. Using `assert`, we can check the value of `tag` all through the loop: | def remove_html_markup_with_tag_assert(s):
tag = False
quote = False
out = ""
for c in s:
assert not tag # <=== Just added
if c == '<' and not quote:
tag = True
elif c == '>' and not quote:
tag = False
elif c == '"' or c == "'" and tag:
quote = not quote
elif not tag:
out = out + c
return out | _____no_output_____ | MIT | Intro_Debugging.ipynb | doscac/ReducingCode |
Our expectation is that this assertion would fail. So, do we actually get an exception? Try it out for yourself by uncommenting the following line: | # remove_html_markup_with_tag_assert('"foo"')
quiz("What happens after inserting the above assertion?",
["The program raises an exception. (i.e., tag is set)",
"The output is as before, i.e., foo without quotes."
" (which means that tag is not set)"],
2) | _____no_output_____ | MIT | Intro_Debugging.ipynb | doscac/ReducingCode |
Here's the solution: | with ExpectError():
result = remove_html_markup_with_tag_assert('"foo"')
result | _____no_output_____ | MIT | Intro_Debugging.ipynb | doscac/ReducingCode |
Refuting a HypothesisWe did not get an exception, hence we reject our hypothesis:1. ~~The error is due to `tag` being set.~~ Again, let's go back to the only place in our code where quotes are handled:```pythonelif c == '"' or c == "'" and tag: quote = not quote```Because of the assertion, we already know that `tag` is always False. Hence, this condition should never hold either. But maybe there's something wrong with the condition such that it holds? Here's our hypothesis:1. The error is due to the quote condition evaluating to true If the condition evaluates to true, then `quote` should be set. We could now go and assert that `quote` is false; but we only care about the condition. So we insert an assertion that assumes that setting the code setting the `quote` flag is never reached: | def remove_html_markup_with_quote_assert(s):
tag = False
quote = False
out = ""
for c in s:
if c == '<' and not quote:
tag = True
elif c == '>' and not quote:
tag = False
elif c == '"' or c == "'" and tag:
assert False # <=== Just added
quote = not quote
elif not tag:
out = out + c
return out | _____no_output_____ | MIT | Intro_Debugging.ipynb | doscac/ReducingCode |
Our expectation this time again is that the assertion fails. So, do we get an exception this time? Try it out for yourself by uncommenting the following line: | # remove_html_markup_with_quote_assert('"foo"')
quiz("What happens after inserting the 'assert' tag?",
["The program raises an exception (i.e., the quote condition holds)",
"The output is still foo (i.e., the quote condition does not hold)"], 29 % 7) | _____no_output_____ | MIT | Intro_Debugging.ipynb | doscac/ReducingCode |
Here's what happens now that we have the `assert` tag: | with ExpectError():
result = remove_html_markup_with_quote_assert('"foo"') | Traceback (most recent call last):
File "<ipython-input-47-9ce255289291>", line 2, in <module>
result = remove_html_markup_with_quote_assert('"foo"')
File "<ipython-input-44-9c8a53a91780>", line 12, in remove_html_markup_with_quote_assert
assert False # <=== Just added
AssertionError (expected)
| MIT | Intro_Debugging.ipynb | doscac/ReducingCode |
From this observation, we can deduce that our hypothesis is _confirmed_:1. The error is due to the quote condition evaluating to true (CONFIRMED)and the _condition is actually faulty._ It evaluates to True although `tag` is always False:```pythonelif c == '"' or c == "'" and tag: quote = not quote```But this condition holds for single and double quotes. Is there a difference? Let us see whether our observations generalize towards general quotes:1. ~~Double~~ quotes are stripped from the input. We can verify these hypotheses with an additional experiment. We go back to our original implementation (without any asserts), and then check it: | remove_html_markup("'foo'") | _____no_output_____ | MIT | Intro_Debugging.ipynb | doscac/ReducingCode |
Surprise: Our hypothesis is rejected and we can add another observation to our table:|Input|Expectation|Output|Outcome||-----|-----------|------|-------||`'foo'`|`'foo'`|`'foo'`|✔|So, the condition* becomes True when a double quote is seen* becomes False (as it should) with single quotes At this point, you should have enough material to solve the problem. How do we have to fix the condition? Here are four alternatives:```pythonc == "" or c == '' and tag Choice 1c == '"' or c == "'" and not tag Choice 2(c == '"' or c == "'") and tag Choice 3... Something else``` | quiz("How should the condition read?",
["Choice 1", "Choice 2", "Choice 3", "Something else"],
399 % 4) | _____no_output_____ | MIT | Intro_Debugging.ipynb | doscac/ReducingCode |
Fixing the Bug So, you have spotted the defect: In Python (and most other languages), `and` takes precedence over `or`, which is why the condition is wrong. It should read:```python(c == '"' or c == "'") and tag```(Actually, good programmers rarely depend on precedence; it is considered good style to use parentheses lavishly.) So, our hypothesis now has become1. The error is due to the `quote` condition evaluating to True Is this our final hypothesis? We can check our earlier examples whether they should now work well:|Input|Expectation|Output|Outcome||-----|-----------|------|-------||`foo`|`foo`|`foo`|✔||`"foo"`|`"foo"`|`foo`|✘||`"foo"`|`"foo"`|`foo`|✘||`foo`|`foo`|`foo`|✔||`"foo"`|`'foo'`|`foo`|✘||`'foo'`|`'foo'`|`'foo'`|✔|In all of these examples, the `quote` flag should now be set outside of tags; hence, everything should work as expected. In terms of the scientific process, we now have a *theory* – a hypothesis that* is consistent with all earlier observations* predicts future observations (in our case: correct behavior)For debugging, our problems are usually too small for a big word like theory, so we use the word *diagnosis* instead. So is our diagnosis sufficient to fix the bug? Let us check. Checking DiagnosesIn debugging, you should start to fix your code if and only if you have a diagnosis that shows two things:1. **Causality.** Your diagnosis should explain why and how the failure came to be. Hence, it induces a _fix_ that, when applied, should make the failure disappear.2. **Incorrectness.** Your diagnosis should explain why and how the code is _incorrect_ (which in turn suggests how to _correct_ the code). Hence, the fix it induces not only applies to the given failure, but also to all related failures. Showing both these aspects requirements – _causality_ and _incorrectness_ – are crucial for a debugging diagnosis:* If you find that you can change some location to make the failure go away, but are not sure why this location is wrong, then your "fix" may apply only to the symptom rather than the source. Your diagnosis explains _causality_, but not _incorrectness_.* If you find that there is a defect in some code location, but do not verify whether this defect is related to the failure in question, then your "fix" may not address the failure. Your diagnosis addresses _incorrectness_, but not _causality_. When you do have a diagnosis that explains both causality (how the failure came to be), and incorrectness (how to correct the code accordingly), then (and only then!) is it time to actually _fix_ the code accordingly. After applying the fix, the failure should be gone, and no other failure should occur. If the failure persists, this should come as a surprise. Obviously, there is some other aspect that you haven't considered yet, so you have to go back to the drawing board and add another failing test case to the set of observations. Fixing the Code All these things considered, let us go and fix `remove_html_markup()`. We know how the defect _causes_ the failure (by erroneously setting `quote` outside of tags). We know that the line in question is _incorrect_ (as single and double of quotes should be treated similarly). So, our diagnosis shows both causality and incorrectness, and we can go and fix the code accordingly: | def remove_html_markup(s):
tag = False
quote = False
out = ""
for c in s:
if c == '<' and not quote:
tag = True
elif c == '>' and not quote:
tag = False
elif (c == '"' or c == "'") and tag: # <-- FIX
quote = not quote
elif not tag:
out = out + c
return out | _____no_output_____ | MIT | Intro_Debugging.ipynb | doscac/ReducingCode |
We verify that the fix was successful by running our earlier tests. Not only should the previously failing tests now pass, the previously passing tests also should not be affected. Fortunately, all tests now pass: | assert remove_html_markup("Here's some <strong>strong argument</strong>.") == \
"Here's some strong argument."
assert remove_html_markup(
'<input type="text" value="<your name>">') == ""
assert remove_html_markup('<b>foo</b>') == 'foo'
assert remove_html_markup('<b>"foo"</b>') == '"foo"'
assert remove_html_markup('"<b>foo</b>"') == '"foo"'
assert remove_html_markup('<"b">foo</"b">') == 'foo' | _____no_output_____ | MIT | Intro_Debugging.ipynb | doscac/ReducingCode |
So, our hypothesis _was_ a theory, and our diagnosis was correct. Success! Alternate PathsA defect may have more than one hypothesis, and each diagnosis can be obtained by many ways. We could also have started with our other hypothesis2. Tags in double quotes are not strippedand by reasoning and experiments, we would have reached the same conclusion that the condition is faulty:* To strip tags, the `tag` flag must be set (but it is not).* To set the `tag` flag, the `quote` variable must not be set (but it is).* The `quote` flag is set under the given condition (which thus must be faulty).This gets us to the same diagnosis as above – and, of course, the same fix. Homework after the Fix After having successfully validated the fix, we still have some homework to make. Check for further Defect Occurrences First, we may want to check that the underlying mistake was not made elsewhere, too.For an error as with `remove_html_markup()`, it may be wise to check other parts of the code (possibly written by the same programmer) whether Boolean formulas show proper precendence. Consider setting up a static program checker or style checker to catch similar mistakes. Check your TestsIf the defect was not found through testing, now is a good time to make sure it will be found the next time. If you use automated tests, add a test that catches the bug (as well as similar ones), such that you can prevent regressions. Add Assertions To be 100% sure, we could add an assertion to `remove_html_markup()` that checks the final result for correctness. Unfortunately, writing such an assertion is just as complex as writing the function itself.There is one assertion, though, which could be placed in the loop body to catch this kind of errors, and which could remain in the code. Which is it? | quiz("Which assertion would have caught the problem?",
["assert quote and not tag",
"assert quote or not tag",
"assert tag or not quote",
"assert tag and not quote"],
3270 - 3267) | _____no_output_____ | MIT | Intro_Debugging.ipynb | doscac/ReducingCode |
Indeed, the statement```pythonassert tag or not quote```is correct. This excludes the situation of ¬`tag` ∧ `quote` – that is, the `tag` flag is not set, but the `quote` flag is. If you remember our state machine from above, this is actually a state that should never exist: | # ignore
display(state_machine) | _____no_output_____ | MIT | Intro_Debugging.ipynb | doscac/ReducingCode |
Here's our function in its "final" state. As software goes, software is never final – and this may also hold for our function, as there is still room for improvement. For this chapter though, we leave it be. | def remove_html_markup(s):
tag = False
quote = False
out = ""
for c in s:
assert tag or not quote
if c == '<' and not quote:
tag = True
elif c == '>' and not quote:
tag = False
elif (c == '"' or c == "'") and tag:
quote = not quote
elif not tag:
out = out + c
return out | _____no_output_____ | MIT | Intro_Debugging.ipynb | doscac/ReducingCode |
Commit the Fix It may sound obvious, but your fix is worth nothing if it doesn't go into production. Be sure to commit your change to the code repository, together with your diagnosis. If your fix has to be approved by a third party, a good diagnosis on why and what happened is immensely helpful. Close the Bug ReportIf you [systematically track bugs](Tracking.ipynb), and your bug is properly tracked, now is the time to mark the issue as "resolved". Check for duplicates of the issue and check whether they are resolved, too. And now, you are finally done:Time to relax – and look for the next bug! Become a Better DebuggerWe have now systematically fixed a bug. In this book, we will explore a number of techniques to make debugging easier – coming up with automated diagnoses, explanations, even automatic repairs, including for our example above. But there are also number of things _you_ can do to become a better debugger. Follow the ProcessIf you're an experienced programmer, you may have spotted the problem in `remove_html_markup()` immediately, and start fixing the code right away. But this is dangerous and risky.Why is this so? Well, because you should first* try to understand the problem, and * have a full diagnosis before starting to fix away.You _can_ skip these steps, and jump right to your interactive debugger the very moment you see a failure, happily stepping through their program. This may even work well for simple problems, including this one. The risk, however, is that this narrows your view to just this one execution, which limits your ability to understand _all_ the circumstances of the problem. Even worse: If you start "fixing" the bug without exactly understanding the problem, you may end up with an incomplete solution – as illustrated in "The Devil's Guide to Debugging", above. Keep a LogA second risk of starting debugging too soon is that it lets you easily deviate from a systematic process. Remember how we wrote down every experiment in a table? How we numbered every hypothesis? This is not just for teaching. Writing these things down explicitly allow you to keep track of all your observations and hypotheses over time.|Input|Expectation|Output|Outcome||-----|-----------|------|-------||`foo`|`foo`|`foo`|✔|Every time you come up with a new hypothesis, you can immediately check it against your earlier observations, which will help you eliminating unlikely ones from the start. This is a bit like in the classic "Mastermind" board game, in which you have to guess some secret combination of pins, and in which you opponent gives you hints on whether and how your guesses are correct. At any time, you can see your previous guesses (experiments) and the results (observations) you got; any new guess (hypothesis) as to be consistent with the previous observations and experiments.  Keeping such a log also allows you to interrupt your debugging session at any time. You can be home in time, sleep over the problem, and resume the next morning with a refreshed mind. You can even hand over the log to someone else, stating your findings so far.The alternative to having a log is to _keep all in memory_. This only works for short amounts of time, as puts a higher and higher cognitive load on your memory as you debug along. After some time, you will forget earlier observations, which leads to mistakes. Worst of all, any interruption will break your concentration and make you forget things, so you can't stop debugging until you're done.Sure, if you are a real master, you can stay glued to the screen all night. But I'd rather be home in time, thank you. RubberduckingA great technique to revisit your observations and to come up with new hypotheses is to _explain the problem to someone else_. In this process, the "someone else" is important, but even more important is that _you are explaining the problem to yourself_! As Kernighan and Pike \cite{Kernighan1999} put it:> Sometimes it takes no more than a few sentences, followed by an embarrassed "Never mind. I see what's wrong. Sorry to bother you."The reason why this works is that teaching someone else forces you to take different perspectives, and these help you resolving the inconsistency between what you assume and what you actually observe.Since that "someone else" can be totally passive, you can even replace her with an inanimate object to talk to – even a rubber duck. This technique is called *rubber duck debugging* or *rubberducking* – the idea is that you explain your problem to a rubber duck first before interrupting one of your co-workers with the problem. Some programmers, when asked for advice, explicitly request that you "explain your problem to the duck first", knowing that this resolves a good fraction of problems.  The Cost of Debugging\todo{add recent stuff on how much time debugging takes}And it's not only that debugging takes time – the worst thing is that it is a search process, which can take anything between a few minutes and several hours, sometimes even days and weeks. But even if you never know how much time a bug will take, it's a bit of blessing to use a process which gradually gets you towards its cause. History of DebuggingEngineers and programmers have long used the term "bug" for faults in their systems – as if it were something that crept into an otherwise flawless program to cause the effects that none could explain. And from a psychological standpoint, it is far easier to blame some "bug" rather than taking responsibility ourselves. In the end, though, we have to face the fact: We made the bugs, and they are ours to fix.Having said that, there has been one recorded instance where a real bug has crept into a system. That was on September 9, 1947, when a moth got stuck in the relay of a Harvard Mark II machine. This event was logged, and the log book is now on display at the Smithsonian Natural Museum of American History, as "First actual case of bug being found."  The actual term "bug", however, is much older. What do you think is its origin? | import hashlib
bughash = hashlib.md5(b"debug").hexdigest()
quiz('Where has the name "bug" been used to denote disruptive events?',
[
'In the early days of Morse telegraphy, referring to a special key '
'that would send a string of dots',
'Among radio technicians to describe a device that '
'converts electromagnetic field variations into acoustic signals',
"In Shakespeare's " '"Henry VI", referring to a walking spectre',
'In Middle English, where the word "bugge" is the basis for terms '
'like "bugbear" and "bugaboo"'
],
[bughash.index(i) for i in "d42f"]
) | _____no_output_____ | MIT | Intro_Debugging.ipynb | doscac/ReducingCode |
(Source: \cite{jargon}, \cite{wikipedia:debugging}) Synopsis In this chapter, we introduce some basics of how failures come to be as well as a general process for debugging. Lessons Learned1. An _error_ is a deviation from what is correct, right, or true. Specifically, * A _mistake_ is a human act or decision resulting in an error. * A _defect_ is an error in the program code. Also called *bug*. * A _fault_ is an error in the program state. Also called *infection*. * A _failure_ is an externally visible error in the program behavior. Also called *malfunction*.2. In a failing program execution, a mistake by the programmer results in a defect in the code, which creates a fault in the state, which propagates until it results in a failure. Tracing back fault propagation allows to identify the defect that causes the failure.3. In debugging, the _scientific method_ allows to systematically identify failure causes by gradually refining and refuting hypotheses based on experiments and observations.4. Before fixing the defect, have a complete _diagnosis_ that * shows _causality_ (how the defect causes the failure) * shows _incorrectness_ (how the defect is wrong)5. You can become a better debugger by * Following a systematic process like the scientific method * Keeping a log of your observations and hypotheses * Making your observations and conclusions explicit by telling them somebody (or something). Next StepsIn the next chapters, we will learn how to* [trace and observe executions](Tracer.ipynb)* [build your own interactive debugger](Debugger.ipynb)* [locate defects automatically by correlating failures and code coverage](StatisticalDebugger.ipynb)* [identify and simplify failure-inducing inputs](Reducer.ipynb)Enjoy! BackgroundThere are several good books on debugging, but these three are especially recommended:* _Debugging_ by Agans \cite{agans2006-debugging} takes a pragmatic approach to debugging, highlighting systematic approaches that help for all kinds of application-specific problems;* _Why Programs Fail_ by Zeller \cite{zeller2009-why-programs-fail} takes a more academic approach, creating theories of how failures come to be and systematic debugging processes;* _Effective Debugging_ by Spinellis \cite{spinellis2016-effective-debugging} aims for a middle ground between the two, creating general recipes and recommendations that easily instantiate towards specific problems.All these books focus on _manual_ debugging and the debugging process, just like this chapter; for _automated_ debugging, simply read on :-) Exercises Exercise 1: Get Acquainted with Notebooks and PythonYour first exercise in this book is to get acquainted with notebooks and Python, such that you can run the code examples in the book – and try out your own. Here are a few tasks to get you started. Beginner Level: Run Notebooks in Your BrowserThe easiest way to get access to the code is to run them in your browser.1. From the [Web Page](__CHAPTER_HTML__), check out the menu at the top. Select `Resources` $\rightarrow$ `Edit as Notebook`.2. After a short waiting time, this will open a Jupyter Notebook right within your browser, containing the current chapter as a notebook.3. You can again scroll through the material, but you click on any code example to edit and run its code (by entering Shift + Return). You can edit the examples as you please.4. Note that code examples typically depend on earlier code, so be sure to run the preceding code first.5. Any changes you make will not be saved (unless you save your notebook to disk).For help on Jupyter Notebooks, from the [Web Page](__CHAPTER_HTML__), check out the `Help` menu. Advanced Level: Run Python Code on Your MachineThis is useful if you want to make greater changes, but do not want to work with Jupyter.1. From the [Web Page](__CHAPTER_HTML__), check out the menu at the top. Select `Resources` $\rightarrow$ `Download Code`. 2. This will download the Python code of the chapter as a single Python .py file, which you can save to your computer.3. You can then open the file, edit it, and run it in your favorite Python environment to re-run the examples.4. Most importantly, you can [import it](Importing.ipynb) into your own code and reuse functions, classes, and other resources.For help on Python, from the [Web Page](__CHAPTER_HTML__), check out the `Help` menu. Pro Level: Run Notebooks on Your MachineThis is useful if you want to work with Jupyter on your machine. This will allow you to also run more complex examples, such as those with graphical output.1. From the [Web Page](__CHAPTER_HTML__), check out the menu at the top. Select `Resources` $\rightarrow$ `All Notebooks`. 2. This will download all Jupyter Notebooks as a collection of .ipynb files, which you can save to your computer.3. You can then open the notebooks in Jupyter Notebook or Jupyter Lab, edit them, and run them. To navigate across notebooks, open the notebook [`00_Table_of_Contents.ipynb`](00_Table_of_Contents.ipynb).4. You can also download individual notebooks using Select `Resources` $\rightarrow$ `Download Notebook`. Running these, however, will require that you have the other notebooks downloaded already.For help on Jupyter Notebooks, from the [Web Page](__CHAPTER_HTML__), check out the `Help` menu. Boss Level: Contribute!This is useful if you want to contribute to the book with patches or other material. It also gives you access to the very latest version of the book.1. From the [Web Page](__CHAPTER_HTML__), check out the menu at the top. Select `Resources` $\rightarrow$ `Project Page`. 2. This will get you to the GitHub repository which contains all sources of the book, including the latest notebooks.3. You can then _clone_ this repository to your disk, such that you get the latest and greatest.4. You can report issues and suggest pull requests on the GitHub page.5. Updating the repository with `git pull` will get you updated.If you want to contribute code or text, check out the [Guide for Authors](Guide_for_Authors.ipynb). Exercise 2: More Bugs!You may have noticed that our `remove_html_markup()` function is still not working perfectly under all circumstances. The error has something to do with different quotes occurring in the input. Part 1: Find the ProblemWhat does the problem look like? Set up a test case that demonstrates the problem. | assert(...) | _____no_output_____ | MIT | Intro_Debugging.ipynb | doscac/ReducingCode |
Set up additional test cases as useful. **Solution.** The remaining problem stems from the fact that in `remove_html_markup()`, we do not differentiate between single and double quotes. Hence, if we have a _quote within a quoted text_, the function may get confused. Notably, a string that begins with a double quote may be interpreted as ending when a single quote is seen, and vice versa. Here's an example of such a string:```html">foo``` When we remove the HTML markup, the `>` in the string is interpreted as _unquoted_. Hence, it is interpreted as ending the tag, such that the rest of the tag is not removed. | s = '<b title="<Shakespeare' + "'s play>" + '">foo</b>'
s
remove_html_markup(s)
with ExpectError():
assert(remove_html_markup(s) == "foo") | Traceback (most recent call last):
File "<ipython-input-60-00bc84e50798>", line 2, in <module>
assert(remove_html_markup(s) == "foo")
AssertionError (expected)
| MIT | Intro_Debugging.ipynb | doscac/ReducingCode |
Part 2: Identify Extent and CauseUsing the scientific method, identify the extent and cause of the problem. Write down your hypotheses and log your observations, as in|Input|Expectation|Output|Outcome||-----|-----------|------|-------||(input)|(expectation)|(output)|(outcome)| **Solution.** The first step is obviously|Input|Expectation|Output|Outcome||-----|-----------|------|-------||">foo|foo|"foo|✘| Part 3: Fix the ProblemDesign a fix for the problem. Show that it satisfies the earlier tests and does not violate any existing test. **Solution**. Here's an improved implementation that actually tracks the opening and closing quote by storing the quoting character in the `quote` variable. (If `quote` is `''`, we are not in a string.) | def remove_html_markup_with_proper_quotes(s):
tag = False
quote = ''
out = ""
for c in s:
assert tag or quote == ''
if c == '<' and quote == '':
tag = True
elif c == '>' and quote == '':
tag = False
elif (c == '"' or c == "'") and tag and quote == '':
# beginning of string
quote = c
elif c == quote:
# end of string
quote = ''
elif not tag:
out = out + c
return out | _____no_output_____ | MIT | Intro_Debugging.ipynb | doscac/ReducingCode |
Python enthusiasts may note that we could also write `not quote` instead of `quote == ''`, leaving most of the original code untouched. We stick to classic Boolean comparisons here. The function now satisfies the earlier failing test: | assert(remove_html_markup_with_proper_quotes(s) == "foo") | _____no_output_____ | MIT | Intro_Debugging.ipynb | doscac/ReducingCode |
as well as all our earlier tests: | assert remove_html_markup_with_proper_quotes(
"Here's some <strong>strong argument</strong>.") == \
"Here's some strong argument."
assert remove_html_markup_with_proper_quotes(
'<input type="text" value="<your name>">') == ""
assert remove_html_markup_with_proper_quotes('<b>foo</b>') == 'foo'
assert remove_html_markup_with_proper_quotes('<b>"foo"</b>') == '"foo"'
assert remove_html_markup_with_proper_quotes('"<b>foo</b>"') == '"foo"'
assert remove_html_markup_with_proper_quotes('<"b">foo</"b">') == 'foo' | _____no_output_____ | MIT | Intro_Debugging.ipynb | doscac/ReducingCode |
Copyright 2017 Google LLC. | # Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
# https://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License. | _____no_output_____ | MIT | dl/google-ml-crashcourse/exercises/01_first_steps_with_tensor_flow.ipynb | AtmaMani/pyChakras |
First Steps with TensorFlow **Learning Objectives:** * Learn fundamental TensorFlow concepts * Use the `LinearRegressor` class in TensorFlow to predict median housing price, at the granularity of city blocks, based on one input feature * Evaluate the accuracy of a model's predictions using Root Mean Squared Error (RMSE) * Improve the accuracy of a model by tuning its hyperparameters The [data](https://developers.google.com/machine-learning/crash-course/california-housing-data-description) is based on 1990 census data from California. SetupIn this first cell, we'll load the necessary libraries. | from __future__ import print_function
import math
from IPython import display
from matplotlib import cm
from matplotlib import gridspec
from matplotlib import pyplot as plt
import numpy as np
import pandas as pd
from sklearn import metrics
import tensorflow as tf
from tensorflow.python.data import Dataset
tf.logging.set_verbosity(tf.logging.ERROR)
pd.options.display.max_rows = 10
pd.options.display.float_format = '{:.1f}'.format | _____no_output_____ | MIT | dl/google-ml-crashcourse/exercises/01_first_steps_with_tensor_flow.ipynb | AtmaMani/pyChakras |
Next, we'll load our data set. | california_housing_dataframe = pd.read_csv("https://download.mlcc.google.com/mledu-datasets/california_housing_train.csv", sep=",")
california_housing_dataframe.head()
california_housing_dataframe.shape | _____no_output_____ | MIT | dl/google-ml-crashcourse/exercises/01_first_steps_with_tensor_flow.ipynb | AtmaMani/pyChakras |
We'll randomize the data, just to be sure not to get any pathological ordering effects that might harm the performance of Stochastic Gradient Descent. Additionally, we'll scale `median_house_value` to be in units of thousands, so it can be learned a little more easily with learning rates in a range that we usually use. | california_housing_dataframe = california_housing_dataframe.reindex(
np.random.permutation(california_housing_dataframe.index))
california_housing_dataframe["median_house_value"] /= 1000.0
california_housing_dataframe | _____no_output_____ | MIT | dl/google-ml-crashcourse/exercises/01_first_steps_with_tensor_flow.ipynb | AtmaMani/pyChakras |
Examine the DataIt's a good idea to get to know your data a little bit before you work with it.We'll print out a quick summary of a few useful statistics on each column: count of examples, mean, standard deviation, max, min, and various quantiles. | california_housing_dataframe.describe() | _____no_output_____ | MIT | dl/google-ml-crashcourse/exercises/01_first_steps_with_tensor_flow.ipynb | AtmaMani/pyChakras |
Build the First ModelIn this exercise, we'll try to predict `median_house_value`, which will be our label (sometimes also called a target). We'll use `total_rooms` as our input feature.**NOTE:** Our data is at the city block level, so this feature represents the total number of rooms in that block.To train our model, we'll use the [LinearRegressor](https://www.tensorflow.org/api_docs/python/tf/estimator/LinearRegressor) interface provided by the TensorFlow [Estimator](https://www.tensorflow.org/get_started/estimator) API. This API takes care of a lot of the low-level model plumbing, and exposes convenient methods for performing model training, evaluation, and inference. Step 1: Define Features and Configure Feature Columns In order to import our training data into TensorFlow, we need to specify what type of data each feature contains. There are two main types of data we'll use in this and future exercises:* **Categorical Data**: Data that is textual. In this exercise, our housing data set does not contain any categorical features, but examples you might see would be the home style, the words in a real-estate ad.* **Numerical Data**: Data that is a number (integer or float) and that you want to treat as a number. As we will discuss more later sometimes you might want to treat numerical data (e.g., a postal code) as if it were categorical.In TensorFlow, we indicate a feature's data type using a construct called a **feature column**. Feature columns store only a description of the feature data; they do not contain the feature data itself.To start, we're going to use just one numeric input feature, `total_rooms`. The following code pulls the `total_rooms` data from our `california_housing_dataframe` and defines the feature column using `numeric_column`, which specifies its data is numeric: | # Define the input feature: total_rooms.
my_feature = california_housing_dataframe[["total_rooms"]]
my_feature
# Configure a numeric feature column for total_rooms.
feature_columns = [tf.feature_column.numeric_column("total_rooms")] | _____no_output_____ | MIT | dl/google-ml-crashcourse/exercises/01_first_steps_with_tensor_flow.ipynb | AtmaMani/pyChakras |
**NOTE:** The shape of our `total_rooms` data is a one-dimensional array (a list of the total number of rooms for each block). This is the default shape for `numeric_column`, so we don't have to pass it as an argument. | print(type(feature_columns[0]))
feature_columns | <class 'tensorflow.python.feature_column.feature_column_v2.NumericColumn'>
| MIT | dl/google-ml-crashcourse/exercises/01_first_steps_with_tensor_flow.ipynb | AtmaMani/pyChakras |
Step 2: Define the Target Next, we'll define our target, which is `median_house_value`. Again, we can pull it from our `california_housing_dataframe`: | # Define the label.
targets = california_housing_dataframe["median_house_value"] | _____no_output_____ | MIT | dl/google-ml-crashcourse/exercises/01_first_steps_with_tensor_flow.ipynb | AtmaMani/pyChakras |
Step 3: Configure the LinearRegressor Next, we'll configure a linear regression model using LinearRegressor. We'll train this model using the `GradientDescentOptimizer`, which implements Mini-Batch Stochastic Gradient Descent (SGD). The `learning_rate` argument controls the size of the gradient step.**NOTE:** To be safe, we also apply [gradient clipping](https://developers.google.com/machine-learning/glossary/gradient_clipping) to our optimizer via `clip_gradients_by_norm`. Gradient clipping ensures the magnitude of the gradients do not become too large during training, which can cause gradient descent to fail. | # Use gradient descent as the optimizer for training the model.
my_optimizer=tf.train.GradientDescentOptimizer(learning_rate=0.0000001)
my_optimizer = tf.contrib.estimator.clip_gradients_by_norm(my_optimizer, 5.0)
# Configure the linear regression model with our feature columns and optimizer.
# Set a learning rate of 0.0000001 for Gradient Descent.
linear_regressor = tf.estimator.LinearRegressor(
feature_columns=feature_columns,
optimizer=my_optimizer
)
my_optimizer = tf.train.GradientDescentOptimizer(learning_rate= 0.0000001)
my_optimizer = tf.contrib.estimator.clip_gradients_by_norm(optimizer=my_optimizer, clip_norm=5.0)
linear_regressor = tf.estimator.LinearRegressor(feature_columns = feature_columns, optimizer=my_optimizer)
linear_regressor | _____no_output_____ | MIT | dl/google-ml-crashcourse/exercises/01_first_steps_with_tensor_flow.ipynb | AtmaMani/pyChakras |
Step 4: Define the Input Function To import our California housing data into our `LinearRegressor`, we need to define an input function, which instructs TensorFlow how to preprocessthe data, as well as how to batch, shuffle, and repeat it during model training.First, we'll convert our *pandas* feature data into a dict of NumPy arrays. We can then use the TensorFlow [Dataset API](https://www.tensorflow.org/programmers_guide/datasets) to construct a dataset object from our data, and then breakour data into batches of `batch_size`, to be repeated for the specified number of epochs (num_epochs). **NOTE:** When the default value of `num_epochs=None` is passed to `repeat()`, the input data will be repeated indefinitely.Next, if `shuffle` is set to `True`, we'll shuffle the data so that it's passed to the model randomly during training. The `buffer_size` argument specifiesthe size of the dataset from which `shuffle` will randomly sample.Finally, our input function constructs an iterator for the dataset and returns the next batch of data to the LinearRegressor. | def my_input_fn(features, targets, batch_size=1, shuffle=True, num_epochs=None):
"""Trains a linear regression model of one feature.
Args:
features: pandas DataFrame of features
targets: pandas DataFrame of targets
batch_size: Size of batches to be passed to the model
shuffle: True or False. Whether to shuffle the data.
num_epochs: Number of epochs for which data should be repeated. None = repeat indefinitely
Returns:
Tuple of (features, labels) for next data batch
"""
# Convert pandas data into a dict of np arrays.
features = {key:np.array(value) for key,value in dict(features).items()}
# Construct a dataset, and configure batching/repeating.
ds = Dataset.from_tensor_slices((features,targets)) # warning: 2GB limit
ds = ds.batch(batch_size).repeat(num_epochs)
# Shuffle the data, if specified.
if shuffle:
ds = ds.shuffle(buffer_size=10000)
# Return the next batch of data.
features, labels = ds.make_one_shot_iterator().get_next()
return features, labels | _____no_output_____ | MIT | dl/google-ml-crashcourse/exercises/01_first_steps_with_tensor_flow.ipynb | AtmaMani/pyChakras |
**NOTE:** We'll continue to use this same input function in later exercises. For moredetailed documentation of input functions and the `Dataset` API, see the [TensorFlow Programmer's Guide](https://www.tensorflow.org/programmers_guide/datasets). Step 5: Train the Model We can now call `train()` on our `linear_regressor` to train the model. We'll wrap `my_input_fn` in a `lambda`so we can pass in `my_feature` and `targets` as arguments (see this [TensorFlow input function tutorial](https://www.tensorflow.org/get_started/input_fnpassing_input_fn_data_to_your_model) for more details), and to start, we'lltrain for 100 steps. | _ = linear_regressor.train(
input_fn = lambda:my_input_fn(my_feature, targets),
steps=100
) | _____no_output_____ | MIT | dl/google-ml-crashcourse/exercises/01_first_steps_with_tensor_flow.ipynb | AtmaMani/pyChakras |
Step 6: Evaluate the Model | _ | _____no_output_____ | MIT | dl/google-ml-crashcourse/exercises/01_first_steps_with_tensor_flow.ipynb | AtmaMani/pyChakras |
Let's make predictions on that training data, to see how well our model fit it during training.**NOTE:** Training error measures how well your model fits the training data, but it **_does not_** measure how well your model **_generalizes to new data_**. In later exercises, you'll explore how to split your data to evaluate your model's ability to generalize. | # Create an input function for predictions.
# Note: Since we're making just one prediction for each example, we don't
# need to repeat or shuffle the data here.
prediction_input_fn =lambda: my_input_fn(my_feature, targets, num_epochs=1, shuffle=False)
# Call predict() on the linear_regressor to make predictions.
predictions = linear_regressor.predict(input_fn=prediction_input_fn)
# Format predictions as a NumPy array, so we can calculate error metrics.
predictions = np.array([item['predictions'][0] for item in predictions])
# Print Mean Squared Error and Root Mean Squared Error.
mean_squared_error = metrics.mean_squared_error(predictions, targets)
root_mean_squared_error = math.sqrt(mean_squared_error)
print("Mean Squared Error (on training data): %0.3f" % mean_squared_error)
print("Root Mean Squared Error (on training data): %0.3f" % root_mean_squared_error) | Mean Squared Error (on training data): 56367.025
Root Mean Squared Error (on training data): 237.417
| MIT | dl/google-ml-crashcourse/exercises/01_first_steps_with_tensor_flow.ipynb | AtmaMani/pyChakras |
Is this a good model? How would you judge how large this error is?Mean Squared Error (MSE) can be hard to interpret, so we often look at Root Mean Squared Error (RMSE)instead. A nice property of RMSE is that it can be interpreted on the same scale as the original targets.Let's compare the RMSE to the difference of the min and max of our targets: | min_house_value = california_housing_dataframe["median_house_value"].min()
max_house_value = california_housing_dataframe["median_house_value"].max()
min_max_difference = max_house_value - min_house_value
print("Min. Median House Value: %0.3f" % min_house_value)
print("Max. Median House Value: %0.3f" % max_house_value)
print("Difference between Min. and Max.: %0.3f" % min_max_difference)
print("Root Mean Squared Error: %0.3f" % root_mean_squared_error) | Min. Median House Value: 14.999
Max. Median House Value: 500.001
Difference between Min. and Max.: 485.002
Root Mean Squared Error: 237.417
| MIT | dl/google-ml-crashcourse/exercises/01_first_steps_with_tensor_flow.ipynb | AtmaMani/pyChakras |
Our error spans nearly half the range of the target values. Can we do better?This is the question that nags at every model developer. Let's develop some basic strategies to reduce model error.The first thing we can do is take a look at how well our predictions match our targets, in terms of overall summary statistics. | calibration_data = pd.DataFrame()
calibration_data["predictions"] = pd.Series(predictions)
calibration_data["targets"] = pd.Series(targets)
calibration_data.describe() | _____no_output_____ | MIT | dl/google-ml-crashcourse/exercises/01_first_steps_with_tensor_flow.ipynb | AtmaMani/pyChakras |
Okay, maybe this information is helpful. How does the mean value compare to the model's RMSE? How about the various quantiles?We can also visualize the data and the line we've learned. Recall that linear regression on a single feature can be drawn as a line mapping input *x* to output *y*.First, we'll get a uniform random sample of the data so we can make a readable scatter plot. | sample = california_housing_dataframe.sample(n=300) | _____no_output_____ | MIT | dl/google-ml-crashcourse/exercises/01_first_steps_with_tensor_flow.ipynb | AtmaMani/pyChakras |
Next, we'll plot the line we've learned, drawing from the model's bias term and feature weight, together with the scatter plot. The line will show up red. | # Get the min and max total_rooms values.
x_0 = sample["total_rooms"].min()
x_1 = sample["total_rooms"].max()
# Retrieve the final weight and bias generated during training.
weight = linear_regressor.get_variable_value('linear/linear_model/total_rooms/weights')[0]
bias = linear_regressor.get_variable_value('linear/linear_model/bias_weights')
# Get the predicted median_house_values for the min and max total_rooms values.
y_0 = weight * x_0 + bias
y_1 = weight * x_1 + bias
# Plot our regression line from (x_0, y_0) to (x_1, y_1).
plt.plot([x_0, x_1], [y_0, y_1], c='r')
# Label the graph axes.
plt.ylabel("median_house_value")
plt.xlabel("total_rooms")
# Plot a scatter plot from our data sample.
plt.scatter(sample["total_rooms"], sample["median_house_value"])
# Display graph.
plt.show() | _____no_output_____ | MIT | dl/google-ml-crashcourse/exercises/01_first_steps_with_tensor_flow.ipynb | AtmaMani/pyChakras |
This initial line looks way off. See if you can look back at the summary stats and see the same information encoded there.Together, these initial sanity checks suggest we may be able to find a much better line. Tweak the Model HyperparametersFor this exercise, we've put all the above code in a single function for convenience. You can call the function with different parameters to see the effect.In this function, we'll proceed in 10 evenly divided periods so that we can observe the model improvement at each period.For each period, we'll compute and graph training loss. This may help you judge when a model is converged, or if it needs more iterations.We'll also plot the feature weight and bias term values learned by the model over time. This is another way to see how things converge. | def train_model(learning_rate, steps, batch_size, input_feature="total_rooms"):
"""Trains a linear regression model of one feature.
Args:
learning_rate: A `float`, the learning rate.
steps: A non-zero `int`, the total number of training steps. A training step
consists of a forward and backward pass using a single batch.
batch_size: A non-zero `int`, the batch size.
input_feature: A `string` specifying a column from `california_housing_dataframe`
to use as input feature.
"""
periods = 10
steps_per_period = steps / periods
my_feature = input_feature
my_feature_data = california_housing_dataframe[[my_feature]]
my_label = "median_house_value"
targets = california_housing_dataframe[my_label]
# Create feature columns.
feature_columns = [tf.feature_column.numeric_column(my_feature)]
# Create input functions.
training_input_fn = lambda:my_input_fn(my_feature_data, targets, batch_size=batch_size)
prediction_input_fn = lambda: my_input_fn(my_feature_data, targets, num_epochs=1, shuffle=False)
# Create a linear regressor object.
my_optimizer = tf.train.GradientDescentOptimizer(learning_rate=learning_rate)
my_optimizer = tf.contrib.estimator.clip_gradients_by_norm(my_optimizer, 5.0)
linear_regressor = tf.estimator.LinearRegressor(
feature_columns=feature_columns,
optimizer=my_optimizer
)
# Set up to plot the state of our model's line each period.
plt.figure(figsize=(15, 6))
plt.subplot(1, 2, 1)
plt.title("Learned Line by Period")
plt.ylabel(my_label)
plt.xlabel(my_feature)
sample = california_housing_dataframe.sample(n=300)
plt.scatter(sample[my_feature], sample[my_label])
colors = [cm.coolwarm(x) for x in np.linspace(-1, 1, periods)]
# Train the model, but do so inside a loop so that we can periodically assess
# loss metrics.
print("Training model...")
print("RMSE (on training data):")
root_mean_squared_errors = []
for period in range (0, periods):
# Train the model, starting from the prior state.
linear_regressor.train(
input_fn=training_input_fn,
steps=steps_per_period
)
# Take a break and compute predictions.
predictions = linear_regressor.predict(input_fn=prediction_input_fn)
predictions = np.array([item['predictions'][0] for item in predictions])
# Compute loss.
root_mean_squared_error = math.sqrt(
metrics.mean_squared_error(predictions, targets))
# Occasionally print the current loss.
print(" period %02d : %0.2f" % (period, root_mean_squared_error))
# Add the loss metrics from this period to our list.
root_mean_squared_errors.append(root_mean_squared_error)
# Finally, track the weights and biases over time.
# Apply some math to ensure that the data and line are plotted neatly.
y_extents = np.array([0, sample[my_label].max()])
weight = linear_regressor.get_variable_value('linear/linear_model/%s/weights' % input_feature)[0]
bias = linear_regressor.get_variable_value('linear/linear_model/bias_weights')
x_extents = (y_extents - bias) / weight
x_extents = np.maximum(np.minimum(x_extents,
sample[my_feature].max()),
sample[my_feature].min())
y_extents = weight * x_extents + bias
plt.plot(x_extents, y_extents, color=colors[period])
print("Model training finished.")
# Output a graph of loss metrics over periods.
plt.subplot(1, 2, 2)
plt.ylabel('RMSE')
plt.xlabel('Periods')
plt.title("Root Mean Squared Error vs. Periods")
plt.tight_layout()
plt.plot(root_mean_squared_errors)
# Output a table with calibration data.
calibration_data = pd.DataFrame()
calibration_data["predictions"] = pd.Series(predictions)
calibration_data["targets"] = pd.Series(targets)
display.display(calibration_data.describe())
print("Final RMSE (on training data): %0.2f" % root_mean_squared_error) | _____no_output_____ | MIT | dl/google-ml-crashcourse/exercises/01_first_steps_with_tensor_flow.ipynb | AtmaMani/pyChakras |
Task 1: Achieve an RMSE of 180 or BelowTweak the model hyperparameters to improve loss and better match the target distribution.If, after 5 minutes or so, you're having trouble beating a RMSE of 180, check the solution for a possible combination. | train_model(
learning_rate=0.0001,
steps=500,
batch_size=100
) | Training model...
RMSE (on training data):
period 00 : 186.29
period 01 : 167.02
period 02 : 166.39
period 03 : 166.39
period 04 : 166.39
period 05 : 166.73
period 06 : 166.73
period 07 : 166.39
period 08 : 166.39
period 09 : 166.73
Model training finished.
| MIT | dl/google-ml-crashcourse/exercises/01_first_steps_with_tensor_flow.ipynb | AtmaMani/pyChakras |
SolutionClick below for one possible solution. | train_model(
learning_rate=0.00002,
steps=500,
batch_size=5
) | Training model...
RMSE (on training data):
period 00 : 225.63
period 01 : 214.42
period 02 : 204.04
period 03 : 194.62
period 04 : 186.92
period 05 : 180.00
period 06 : 174.79
period 07 : 171.23
period 08 : 169.08
period 09 : 167.89
Model training finished.
| MIT | dl/google-ml-crashcourse/exercises/01_first_steps_with_tensor_flow.ipynb | AtmaMani/pyChakras |
This is just one possible configuration; there may be other combinations of settings that also give good results. Note that in general, this exercise isn't about finding the *one best* setting, but to help build your intutions about how tweaking the model configuration affects prediction quality. Is There a Standard Heuristic for Model Tuning?This is a commonly asked question. The short answer is that the effects of different hyperparameters are data dependent. So there are no hard-and-fast rules; you'll need to test on your data.That said, here are a few rules of thumb that may help guide you: * Training error should steadily decrease, steeply at first, and should eventually plateau as training converges. * If the training has not converged, try running it for longer. * If the training error decreases too slowly, increasing the learning rate may help it decrease faster. * But sometimes the exact opposite may happen if the learning rate is too high. * If the training error varies wildly, try decreasing the learning rate. * Lower learning rate plus larger number of steps or larger batch size is often a good combination. * Very small batch sizes can also cause instability. First try larger values like 100 or 1000, and decrease until you see degradation.Again, never go strictly by these rules of thumb, because the effects are data dependent. Always experiment and verify. Task 2: Try a Different FeatureSee if you can do any better by replacing the `total_rooms` feature with the `population` feature.Don't take more than 5 minutes on this portion. | # YOUR CODE HERE | _____no_output_____ | MIT | dl/google-ml-crashcourse/exercises/01_first_steps_with_tensor_flow.ipynb | AtmaMani/pyChakras |
SolutionClick below for one possible solution. | train_model(
learning_rate=0.00002,
steps=1000,
batch_size=5,
input_feature="population"
) | Training model...
RMSE (on training data):
period 00 : 225.63
period 01 : 214.62
period 02 : 204.86
period 03 : 196.75
period 04 : 190.21
period 05 : 185.13
period 06 : 181.19
period 07 : 178.67
period 08 : 177.16
period 09 : 176.26
Model training finished.
| MIT | dl/google-ml-crashcourse/exercises/01_first_steps_with_tensor_flow.ipynb | AtmaMani/pyChakras |
Homework 4The homework consists of two parts: theoretical part (5 pts) and coding part (25 pts). - All theoretical questions must be answered in your own words, do not copy-paste text from the internet. Points can be deducted for terrible formatting or incomprehensible English. - Code must be commented. If you use code you found online, you have to add the link to the source you used. There is no penalty for using outside sources as long as you convince us you understand the code.**You can earn up to 5 bonus points by completing the additional notebook about dropout.***Once completed zip the entire directory containing this exercise and upload it to https://courses.cs.ut.ee/2020/nn/spring/Main/Practices.* If you did this homework together with course mates, please write here their names (answers still have to be your own!).**Name(s):** fill this in if applicable Part 1: Lecture Materials (5 pts)These theoretical questions are about the material covered in the lecture about "Optimization and regularization". Optimization methods**Task 1.1: Optimization methods (3pt)**In the coding task you will be asked to implement multiple improvements to the naive approach to the stochastic gradient descent (SGD). You can find the descriptions of the optimization methods at http://cs231n.github.io/neural-networks-3. Please find the following update rules from the document and explain in 1-2 sentences:* SGD with momentum. Explain what is $v$. Why might it be useful to use $v$ instead of $dx$ when updating the values of $x$.* RMSprop optimizer. Explain what the cache variable represents.* Adam optimizer, simplified form. Explain what is the difference with RMSProp **Your Answer:**- 𝑣 means *velocity*. It might be useful compare to $dx$, because using only $dx$ can be pointed to inaccurate result or too large a step- The cache variable represent the accumulation of history of the squared gradients.- Adam can be looked as the combination of RMSProp and SGD with momentum. Using the squared gradients to scale the learning rate like RMSprop and also takes advantage of momentum by using moving average of the gradient.[Reference](https://towardsdatascience.com/adam-latest-trends-in-deep-learning-optimization-6be9a291375c) **Task 1.2: Dropout basics (2pt)**We are training a model with one hidden layer containing 10 hidden nodes. We use dropout on the nodes of that hidden layer, such that at each training step we drop out exactly 2 random nodes of that layer.* over many (millions) training steps how many different models do we use (how many different ways of dropping out exactly two nodes there is)? Notice that the order of dropping nodes does not matter!* When using this model at testing phase, with what constant do we need to multiply/divide the weights going out from this layer? **Your Answer:**- USing this formula to calculate the combinations of the hiddens layer, $C(n,k)=\frac{n!}{(n-k!)*k!}=\frac{10!}{(10-8!)*8!}=45$- Weights need to be multiplied with the constant value of the proabibility of the nodes kept, `8/10 = 0.8` Part 2: practical tasks Fully-Connected Neural NetsIn the previous homework you implemented a fully-connected two-layer neural network on CIFAR-10. The implementation was simple but not very modular since the loss and gradient were computed in a single monolithic function. This is manageable for a simple two-layer network, but would become impractical as we move to bigger models. Ideally we want to build networks using a more modular design so that we can implement different layer types in isolation and then snap them together into models with different architectures.In this exercise we will implement fully-connected networks using a more modular approach. For each layer we will implement a `forward` and a `backward` function. The `forward` function will receive inputs, weights, and other parameters and will return both an output and a `cache` object storing data needed for the backward pass, like this:```pythondef layer_forward(x, w): """ Receive inputs x and weights w """ Do some computations ... z = ... some intermediate value Do some more computations ... out = the output cache = (x, w, z, out) Values we need to compute gradients return out, cache```The backward pass will receive upstream derivatives and the `cache` object, and will return gradients with respect to the inputs and weights, like this:```pythondef layer_backward(dout, cache): """ Receive derivative of loss with respect to outputs and cache, and compute derivative with respect to inputs. """ Unpack cache values x, w, z, out = cache Use values in cache to compute derivatives dx = Derivative of loss with respect to x dw = Derivative of loss with respect to w return dx, dw```After implementing a bunch of layers this way, we will be able to easily combine them to build classifiers with different architectures.For additional background reading see http://cs231n.github.io/neural-networks-1/, http://cs231n.github.io/neural-networks-2/ and http://cs231n.github.io/neural-networks-3/. | # As usual, a bit of setup
from __future__ import print_function
import time
import numpy as np
import matplotlib.pyplot as plt
from fc_net import *
from data_utils import get_CIFAR10_data
from gradient_check import eval_numerical_gradient, eval_numerical_gradient_array
from solver import Solver
%matplotlib inline
plt.rcParams['figure.figsize'] = (10.0, 8.0) # set default size of plots
plt.rcParams['image.interpolation'] = 'nearest'
plt.rcParams['image.cmap'] = 'gray'
# for auto-reloading external modules
# see http://stackoverflow.com/questions/1907993/autoreload-of-modules-in-ipython
%load_ext autoreload
%autoreload 2
def rel_error(x, y):
""" returns relative error """
return np.max(np.abs(x - y) / (np.maximum(1e-8, np.abs(x) + np.abs(y))))
# Load the (preprocessed) CIFAR10 data.
data = get_CIFAR10_data('../datasets/cifar-10-batches-py')
for k, v in list(data.items()):
print(('%s: ' % k, v.shape)) | ('X_train: ', (49000, 3, 32, 32))
('y_train: ', (49000,))
('X_val: ', (1000, 3, 32, 32))
('y_val: ', (1000,))
('X_test: ', (1000, 3, 32, 32))
('y_test: ', (1000,))
| MIT | practice4/FullyConnectedNets_plus_bonus.ipynb | enliktjioe/nn2020 |
Affine layer: foward**Task 2.1.1 (1pt):**Open the file `layers.py` and implement the `affine_forward` function. Once you are done you can test your implementaion by running the following: | # Test the affine_forward function
num_inputs = 2
input_shape = (4, 5, 6)
output_dim = 3
input_size = num_inputs * np.prod(input_shape)
weight_size = output_dim * np.prod(input_shape)
x = np.linspace(-0.1, 0.5, num=input_size).reshape(num_inputs, *input_shape)
w = np.linspace(-0.2, 0.3, num=weight_size).reshape(np.prod(input_shape), output_dim)
b = np.linspace(-0.3, 0.1, num=output_dim)
out, _ = affine_forward(x, w, b)
correct_out = np.array([[ 1.49834967, 1.70660132, 1.91485297],
[ 3.25553199, 3.5141327, 3.77273342]])
# Compare your output with ours. The error should be around 1e-9.
print('Testing affine_forward function:')
print('difference: ', rel_error(out, correct_out)) | Testing affine_forward function:
difference: 9.7698500479884e-10
| MIT | practice4/FullyConnectedNets_plus_bonus.ipynb | enliktjioe/nn2020 |
Affine layer: backward**Task 2.1.2 (1pt):**Now implement the `affine_backward` function and test your implementation using numeric gradient checking. | # Test the affine_backward function
np.random.seed(231)
x = np.random.randn(10, 2, 3)
w = np.random.randn(6, 5)
b = np.random.randn(5)
dout = np.random.randn(10, 5)
dx_num = eval_numerical_gradient_array(lambda x: affine_forward(x, w, b)[0], x, dout)
dw_num = eval_numerical_gradient_array(lambda w: affine_forward(x, w, b)[0], w, dout)
db_num = eval_numerical_gradient_array(lambda b: affine_forward(x, w, b)[0], b, dout)
_, cache = affine_forward(x, w, b)
dx, dw, db = affine_backward(dout, cache)
# The error should be around 1e-10
print('Testing affine_backward function:')
print('dx error: ', rel_error(dx_num, dx))
print('dw error: ', rel_error(dw_num, dw))
print('db error: ', rel_error(db_num, db)) | Testing affine_backward function:
dx error: 1.0908199508708189e-10
dw error: 2.1752635504596857e-10
db error: 7.736978834487815e-12
| MIT | practice4/FullyConnectedNets_plus_bonus.ipynb | enliktjioe/nn2020 |
ReLU layer: forward**Taks 2.1.3 (1pt):** Implement the forward pass for the ReLU activation function in the `relu_forward` function and test your implementation using the following: | # Test the relu_forward function
x = np.linspace(-0.5, 0.5, num=12).reshape(3, 4)
out, _ = relu_forward(x)
correct_out = np.array([[ 0., 0., 0., 0., ],
[ 0., 0., 0.04545455, 0.13636364,],
[ 0.22727273, 0.31818182, 0.40909091, 0.5, ]])
# Compare your output with ours. The error should be around 5e-8
print('Testing relu_forward function:')
print('difference: ', rel_error(out, correct_out)) | Testing relu_forward function:
difference: 4.999999798022158e-08
| MIT | practice4/FullyConnectedNets_plus_bonus.ipynb | enliktjioe/nn2020 |
ReLU layer: backward**Task 2.1.4 (1pt):** Now implement the backward pass for the ReLU activation function in the `relu_backward` function and test your implementation using numeric gradient checking: | np.random.seed(231)
x = np.random.randn(10, 10)
dout = np.random.randn(*x.shape)
dx_num = eval_numerical_gradient_array(lambda x: relu_forward(x)[0], x, dout)
_, cache = relu_forward(x)
dx = relu_backward(dout, cache)
# The error should be around 3e-12
print('Testing relu_backward function:')
print('dx error: ', rel_error(dx_num, dx)) | Testing relu_backward function:
dx error: 3.2756349136310288e-12
| MIT | practice4/FullyConnectedNets_plus_bonus.ipynb | enliktjioe/nn2020 |
"Sandwich" layersThere are some common patterns of layers that are frequently used in neural nets. For example, affine layers are frequently followed by a ReLU nonlinearity. To make these common patterns easy, we define several convenience layers in the file `layer_utils.py`.For now take a look at the `affine_relu_forward` and `affine_relu_backward` functions, and run the following to numerically gradient check the backward pass: | from layer_utils import affine_relu_forward, affine_relu_backward
np.random.seed(231)
x = np.random.randn(2, 3, 4)
w = np.random.randn(12, 10)
b = np.random.randn(10)
dout = np.random.randn(2, 10)
out, cache = affine_relu_forward(x, w, b)
dx, dw, db = affine_relu_backward(dout, cache)
dx_num = eval_numerical_gradient_array(lambda x: affine_relu_forward(x, w, b)[0], x, dout)
dw_num = eval_numerical_gradient_array(lambda w: affine_relu_forward(x, w, b)[0], w, dout)
db_num = eval_numerical_gradient_array(lambda b: affine_relu_forward(x, w, b)[0], b, dout)
print('Testing affine_relu_forward:')
print('dx error: ', rel_error(dx_num, dx))
print('dw error: ', rel_error(dw_num, dw))
print('db error: ', rel_error(db_num, db)) | Testing affine_relu_forward:
dx error: 6.395535042049294e-11
dw error: 8.162011105764925e-11
db error: 7.826724021458994e-12
| MIT | practice4/FullyConnectedNets_plus_bonus.ipynb | enliktjioe/nn2020 |
Softmax loss layerYou implemented this loss function in the last assignment, so we'll give it to you for free here. You should still make sure you understand how they work by looking at the implementation in `layers.py`.You can make sure that the implementations are correct by running the following: | np.random.seed(231)
num_classes, num_inputs = 10, 50
x = 0.001 * np.random.randn(num_inputs, num_classes)
y = np.random.randint(num_classes, size=num_inputs)
dx_num = eval_numerical_gradient(lambda x: softmax_loss(x, y)[0], x, verbose=False)
loss, dx = softmax_loss(x, y)
# Test softmax_loss function. Loss should be 2.3 and dx error should be 1e-8
print('Testing softmax_loss:')
print('loss: ', loss)
print('dx error: ', rel_error(dx_num, dx)) | Testing softmax_loss:
loss: 2.302545844500738
dx error: 9.384673161989355e-09
| MIT | practice4/FullyConnectedNets_plus_bonus.ipynb | enliktjioe/nn2020 |
Two-layer networkIn the previous assignment you implemented a two-layer neural network in a single monolithic class. Now that you have implemented modular versions of the necessary layers, you will reimplement the two layer network using these modular implementations.**Task 2.2 (3pts):** Open the file `fc_net.py` and complete the implementation of the `TwoLayerNet` class. This class will serve as a model for the other networks you will implement in this assignment, so read through it to make sure you understand the API. You can run the cell below to test your implementation. | np.random.seed(231)
N, D, H, C = 3, 5, 50, 7
X = np.random.randn(N, D)
y = np.random.randint(C, size=N)
std = 1e-3
model = TwoLayerNet(input_dim=D, hidden_dim=H, num_classes=C, weight_scale=std)
print('Testing initialization ... ')
W1_std = abs(model.params['W1'].std() - std)
b1 = model.params['b1']
W2_std = abs(model.params['W2'].std() - std)
b2 = model.params['b2']
assert W1_std < std / 10, 'First layer weights do not seem right'
assert np.all(b1 == 0), 'First layer biases do not seem right'
assert W2_std < std / 10, 'Second layer weights do not seem right'
assert np.all(b2 == 0), 'Second layer biases do not seem right'
print('Testing test-time forward pass ... ')
model.params['W1'] = np.linspace(-0.7, 0.3, num=D*H).reshape(D, H)
model.params['b1'] = np.linspace(-0.1, 0.9, num=H)
model.params['W2'] = np.linspace(-0.3, 0.4, num=H*C).reshape(H, C)
model.params['b2'] = np.linspace(-0.9, 0.1, num=C)
X = np.linspace(-5.5, 4.5, num=N*D).reshape(D, N).T
scores = model.loss(X)
correct_scores = np.asarray(
[[11.53165108, 12.2917344, 13.05181771, 13.81190102, 14.57198434, 15.33206765, 16.09215096],
[12.05769098, 12.74614105, 13.43459113, 14.1230412, 14.81149128, 15.49994135, 16.18839143],
[12.58373087, 13.20054771, 13.81736455, 14.43418138, 15.05099822, 15.66781506, 16.2846319 ]])
scores_diff = np.abs(scores - correct_scores).sum()
assert scores_diff < 1e-6, 'Problem with test-time forward pass'
print('Testing training loss (no regularization)')
y = np.asarray([0, 5, 1])
loss, grads = model.loss(X, y)
correct_loss = 3.4702243556
assert abs(loss - correct_loss) < 1e-10, 'Problem with training-time loss'
model.reg = 1.0
loss, grads = model.loss(X, y)
correct_loss = 26.5948426952
assert abs(loss - correct_loss) < 1e-10, 'Problem with regularization loss'
for reg in [0.0, 0.7]:
print('Running numeric gradient check with reg = ', reg)
model.reg = reg
loss, grads = model.loss(X, y)
for name in sorted(grads):
f = lambda _: model.loss(X, y)[0]
grad_num = eval_numerical_gradient(f, model.params[name], verbose=False)
print('%s relative error: %.2e' % (name, rel_error(grad_num, grads[name])))
assert rel_error(grad_num, grads[name]) < 0.6, "Error with gradient for " + name | Testing initialization ...
Testing test-time forward pass ...
Testing training loss (no regularization)
Running numeric gradient check with reg = 0.0
W1 relative error: 1.22e-08
W2 relative error: 3.17e-10
b1 relative error: 6.19e-09
b2 relative error: 4.33e-10
Running numeric gradient check with reg = 0.7
W1 relative error: 2.53e-07
W2 relative error: 1.37e-07
b1 relative error: 1.56e-08
b2 relative error: 9.09e-10
| MIT | practice4/FullyConnectedNets_plus_bonus.ipynb | enliktjioe/nn2020 |
SolverIn the previous assignment, the logic for training models was coupled to the models themselves. Following a more modular design, for this assignment we have split the logic for training models into a separate class.**Task 2.3 (1pt):** Open the file `solver.py` and read through it to familiarize yourself with the API. After doing so, use a `Solver` instance to train a `TwoLayerNet` that achieves at least `50%` accuracy on the validation set. | model = TwoLayerNet()
solver = None
##############################################################################
# TODO: Use a Solver instance to train a TwoLayerNet that achieves at least #
# 50% accuracy on the validation set. #
##############################################################################
# Use Solver instance with learning rate = 0.001, 20 epochs, and
# batch size of 400 which gave the best accuracy
solver = Solver(model, data, update_rule = 'sgd',
optim_config = {
'learning_rate': 1e-3,
},
lr_decay = 0.95,
num_epochs = 20,
batch_size = 400,
print_every = 100
)
solver.train()
##############################################################################
# END OF YOUR CODE #
##############################################################################
# Run this cell to visualize training loss and train / val accuracy
plt.subplot(2, 1, 1)
plt.title('Training loss')
plt.plot(solver.loss_history, 'o')
plt.xlabel('Iteration')
plt.subplot(2, 1, 2)
plt.title('Accuracy')
plt.plot(solver.train_acc_history, '-o', label='train')
plt.plot(solver.val_acc_history, '-o', label='val')
plt.plot([0.5] * len(solver.val_acc_history), 'k--')
plt.xlabel('Epoch')
plt.legend(loc='lower right')
plt.gcf().set_size_inches(15, 12)
plt.show() | _____no_output_____ | MIT | practice4/FullyConnectedNets_plus_bonus.ipynb | enliktjioe/nn2020 |
Multilayer networkNext you will implement a fully-connected network with an arbitrary number of hidden layers. Read through the `FullyConnectedNet` class in the file `fc_net.py`.**Task 2.4.1 (6pts):** Implement the initialization, the forward pass, and the backward pass. For the moment don't worry about implementing dropout or batch normalization; we will add those features soon. Initial loss and gradient check As a sanity check, run the following to check the initial loss and to gradient check the network both with and without regularization. Do the initial losses seem reasonable?For gradient checking, you should expect to see errors around 1e-6 or less. | np.random.seed(231)
N, D, H1, H2, C = 2, 15, 20, 30, 10
X = np.random.randn(N, D)
y = np.random.randint(C, size=(N,))
for reg in [0, 3.14]:
print('Running check with reg = ', reg)
model = FullyConnectedNet([H1, H2], input_dim=D, num_classes=C,
reg=reg, weight_scale=5e-2, dtype=np.float64)
loss, grads = model.loss(X, y)
print('Initial loss: ', loss)
for name in sorted(grads):
f = lambda _: model.loss(X, y)[0]
grad_num = eval_numerical_gradient(f, model.params[name], verbose=False, h=1e-5)
print('%s relative error: %.2e' % (name, rel_error(grad_num, grads[name])))
assert rel_error(grad_num, grads[name]) < 1e-4 | Running check with reg = 0
Initial loss: 2.3004790897684924
W1 relative error: 1.48e-07
W2 relative error: 2.21e-05
W3 relative error: 3.53e-07
b1 relative error: 5.38e-09
b2 relative error: 2.09e-09
b3 relative error: 5.80e-11
Running check with reg = 3.14
Initial loss: 7.052114776533016
W1 relative error: 6.86e-09
W2 relative error: 3.52e-08
W3 relative error: 1.32e-08
b1 relative error: 1.48e-08
b2 relative error: 1.72e-09
b3 relative error: 1.80e-10
| MIT | practice4/FullyConnectedNets_plus_bonus.ipynb | enliktjioe/nn2020 |
**Task 2.4.2 (1pt):** As another sanity check, make sure you can overfit a small dataset of 50 images. First we will try a three-layer network with 100 units in each hidden layer. You will need to tweak the learning rate and initialization scale, but you should be able to overfit and achieve 100% training accuracy within 20 epochs. | # TODO: Use a three-layer Net to overfit 50 training examples.
num_train = 50
small_data = {
'X_train': data['X_train'][:num_train],
'y_train': data['y_train'][:num_train],
'X_val': data['X_val'],
'y_val': data['y_val'],
}
# weight_scale = 1e-2
# learning_rate = 1e-4
# after several test with many values, this value give the best combination to be able to overfit the data
# and achieve 100% training accuracy
weight_scale = 1e-1
learning_rate = 1e-3
model = FullyConnectedNet([100, 100],
weight_scale=weight_scale, dtype=np.float64)
solver = Solver(model, small_data,
print_every=10, num_epochs=20, batch_size=25,
update_rule='sgd',
optim_config={
'learning_rate': learning_rate,
}
)
solver.train()
plt.plot(solver.loss_history, 'o')
plt.title('Training loss history')
plt.xlabel('Iteration')
plt.ylabel('Training loss')
plt.show() | (Iteration 1 / 40) loss: 357.428290
(Epoch 0 / 20) train acc: 0.220000; val_acc: 0.111000
(Epoch 1 / 20) train acc: 0.380000; val_acc: 0.141000
(Epoch 2 / 20) train acc: 0.520000; val_acc: 0.138000
(Epoch 3 / 20) train acc: 0.740000; val_acc: 0.130000
(Epoch 4 / 20) train acc: 0.820000; val_acc: 0.153000
(Epoch 5 / 20) train acc: 0.860000; val_acc: 0.175000
(Iteration 11 / 40) loss: 6.726589
(Epoch 6 / 20) train acc: 0.940000; val_acc: 0.163000
(Epoch 7 / 20) train acc: 0.960000; val_acc: 0.166000
(Epoch 8 / 20) train acc: 0.960000; val_acc: 0.164000
(Epoch 9 / 20) train acc: 0.980000; val_acc: 0.162000
(Epoch 10 / 20) train acc: 0.980000; val_acc: 0.162000
(Iteration 21 / 40) loss: 0.800243
(Epoch 11 / 20) train acc: 1.000000; val_acc: 0.158000
(Epoch 12 / 20) train acc: 1.000000; val_acc: 0.158000
(Epoch 13 / 20) train acc: 1.000000; val_acc: 0.158000
(Epoch 14 / 20) train acc: 1.000000; val_acc: 0.158000
(Epoch 15 / 20) train acc: 1.000000; val_acc: 0.158000
(Iteration 31 / 40) loss: 0.000000
(Epoch 16 / 20) train acc: 1.000000; val_acc: 0.158000
(Epoch 17 / 20) train acc: 1.000000; val_acc: 0.158000
(Epoch 18 / 20) train acc: 1.000000; val_acc: 0.158000
(Epoch 19 / 20) train acc: 1.000000; val_acc: 0.158000
(Epoch 20 / 20) train acc: 1.000000; val_acc: 0.158000
| MIT | practice4/FullyConnectedNets_plus_bonus.ipynb | enliktjioe/nn2020 |
**Task 2.4.2 (1pt):** Now try to use a five-layer network with 100 units on each layer to overfit 50 training examples. Again you will have to adjust the learning rate and weight initialization, but you should be able to achieve 100% training accuracy within 20 epochs. | # TODO: Use a five-layer Net to overfit 50 training examples.
num_train = 50
small_data = {
'X_train': data['X_train'][:num_train],
'y_train': data['y_train'][:num_train],
'X_val': data['X_val'],
'y_val': data['y_val'],
}
# learning_rate = 1e-3
# weight_scale = 1e-5
# Found the best combination learning rate and weight scale to achieve 100$ training accuracy (overfit)
learning_rate = 1e-3
weight_scale = 1e-1
model = FullyConnectedNet([100, 100, 100, 100],
weight_scale=weight_scale, dtype=np.float64)
solver = Solver(model, small_data,
print_every=10, num_epochs=20, batch_size=25,
update_rule='sgd',
optim_config={
'learning_rate': learning_rate,
}
)
solver.train()
plt.plot(solver.loss_history, 'o')
plt.title('Training loss history')
plt.xlabel('Iteration')
plt.ylabel('Training loss')
plt.show() | (Iteration 1 / 40) loss: 166.501707
(Epoch 0 / 20) train acc: 0.220000; val_acc: 0.116000
(Epoch 1 / 20) train acc: 0.240000; val_acc: 0.083000
(Epoch 2 / 20) train acc: 0.160000; val_acc: 0.104000
(Epoch 3 / 20) train acc: 0.520000; val_acc: 0.106000
(Epoch 4 / 20) train acc: 0.700000; val_acc: 0.131000
(Epoch 5 / 20) train acc: 0.700000; val_acc: 0.116000
(Iteration 11 / 40) loss: 4.414592
(Epoch 6 / 20) train acc: 0.840000; val_acc: 0.114000
(Epoch 7 / 20) train acc: 0.880000; val_acc: 0.108000
(Epoch 8 / 20) train acc: 0.900000; val_acc: 0.109000
(Epoch 9 / 20) train acc: 0.960000; val_acc: 0.114000
(Epoch 10 / 20) train acc: 0.980000; val_acc: 0.127000
(Iteration 21 / 40) loss: 0.261098
(Epoch 11 / 20) train acc: 1.000000; val_acc: 0.126000
(Epoch 12 / 20) train acc: 1.000000; val_acc: 0.124000
(Epoch 13 / 20) train acc: 1.000000; val_acc: 0.124000
(Epoch 14 / 20) train acc: 1.000000; val_acc: 0.124000
(Epoch 15 / 20) train acc: 1.000000; val_acc: 0.125000
(Iteration 31 / 40) loss: 0.000594
(Epoch 16 / 20) train acc: 1.000000; val_acc: 0.125000
(Epoch 17 / 20) train acc: 1.000000; val_acc: 0.125000
(Epoch 18 / 20) train acc: 1.000000; val_acc: 0.125000
(Epoch 19 / 20) train acc: 1.000000; val_acc: 0.125000
(Epoch 20 / 20) train acc: 1.000000; val_acc: 0.125000
| MIT | practice4/FullyConnectedNets_plus_bonus.ipynb | enliktjioe/nn2020 |
**Task 2.4.2 (2pt):** Did you notice anything about the comparative difficulty of training the three-layer net vs training the five layer net?**Your Answer:** - Five-layer network is more sensitive to small changes in comparison with three-layer network- With the same weight scale and learning rate, the process of overfitting data using five-layer network is slower compare to three-layer network. Update rulesSo far we have used vanilla stochastic gradient descent (SGD) as our update rule. More sophisticated update rules can make it easier to train deep networks. We will implement a few of the most commonly used update rules and compare them to vanilla SGD.Notice that in the **theory homework**, the first question is also about update rules. You might find it useful to complete the theory in parallel. SGD+MomentumStochastic gradient descent with momentum is a widely used update rule that tends to make deep networks converge faster than vanilla stochstic gradient descent.**Task 2.5.1 (1pt):** Open the file `optim.py` and read the documentation at the top of the file to make sure you understand the API. Implement the SGD+momentum update rule in the function `sgd_momentum` and run the following to check your implementation. You should see errors less than 1e-8. | from optim import sgd_momentum
N, D = 4, 5
w = np.linspace(-0.4, 0.6, num=N*D).reshape(N, D)
dw = np.linspace(-0.6, 0.4, num=N*D).reshape(N, D)
v = np.linspace(0.6, 0.9, num=N*D).reshape(N, D)
config = {'learning_rate': 1e-3, 'velocity': v}
next_w, _ = sgd_momentum(w, dw, config=config)
expected_next_w = np.asarray([
[ 0.1406, 0.20738947, 0.27417895, 0.34096842, 0.40775789],
[ 0.47454737, 0.54133684, 0.60812632, 0.67491579, 0.74170526],
[ 0.80849474, 0.87528421, 0.94207368, 1.00886316, 1.07565263],
[ 1.14244211, 1.20923158, 1.27602105, 1.34281053, 1.4096 ]])
expected_velocity = np.asarray([
[ 0.5406, 0.55475789, 0.56891579, 0.58307368, 0.59723158],
[ 0.61138947, 0.62554737, 0.63970526, 0.65386316, 0.66802105],
[ 0.68217895, 0.69633684, 0.71049474, 0.72465263, 0.73881053],
[ 0.75296842, 0.76712632, 0.78128421, 0.79544211, 0.8096 ]])
print('next_w error: ', rel_error(next_w, expected_next_w))
print('velocity error: ', rel_error(expected_velocity, config['velocity'])) | next_w error: 8.882347033505819e-09
velocity error: 4.269287743278663e-09
| MIT | practice4/FullyConnectedNets_plus_bonus.ipynb | enliktjioe/nn2020 |
Once you have done so, run the following to train a six-layer network with both SGD and SGD+momentum. You should see the SGD+momentum update rule converge faster. | num_train = 4000
small_data = {
'X_train': data['X_train'][:num_train],
'y_train': data['y_train'][:num_train],
'X_val': data['X_val'],
'y_val': data['y_val'],
}
solvers = {}
for update_rule in ['sgd', 'sgd_momentum']:
print('running with ', update_rule)
model = FullyConnectedNet([100, 100, 100, 100, 100], weight_scale=5e-2)
solver = Solver(model, small_data,
num_epochs=5, batch_size=100,
update_rule=update_rule,
optim_config={'learning_rate': 1e-2,},
verbose=True)
solvers[update_rule] = solver
solver.train()
print()
plt.subplot(3, 1, 1)
plt.title('Training loss')
plt.xlabel('Iteration')
plt.subplot(3, 1, 2)
plt.title('Training accuracy')
plt.xlabel('Epoch')
plt.subplot(3, 1, 3)
plt.title('Validation accuracy')
plt.xlabel('Epoch')
for update_rule, solver in list(solvers.items()):
plt.subplot(3, 1, 1)
plt.plot(solver.loss_history, 'o', label=update_rule)
plt.subplot(3, 1, 2)
plt.plot(solver.train_acc_history, '-o', label=update_rule)
plt.subplot(3, 1, 3)
plt.plot(solver.val_acc_history, '-o', label=update_rule)
for i in [1, 2, 3]:
plt.subplot(3, 1, i)
plt.legend(loc='upper center', ncol=4)
plt.gcf().set_size_inches(15, 15)
plt.show() | running with sgd
(Iteration 1 / 200) loss: 2.559978
(Epoch 0 / 5) train acc: 0.103000; val_acc: 0.108000
(Iteration 11 / 200) loss: 2.291086
(Iteration 21 / 200) loss: 2.153591
(Iteration 31 / 200) loss: 2.082693
(Epoch 1 / 5) train acc: 0.277000; val_acc: 0.242000
(Iteration 41 / 200) loss: 2.004171
(Iteration 51 / 200) loss: 2.010409
(Iteration 61 / 200) loss: 2.023753
(Iteration 71 / 200) loss: 2.026621
(Epoch 2 / 5) train acc: 0.352000; val_acc: 0.312000
(Iteration 81 / 200) loss: 1.807163
(Iteration 91 / 200) loss: 1.914256
(Iteration 101 / 200) loss: 1.917177
(Iteration 111 / 200) loss: 1.706193
(Epoch 3 / 5) train acc: 0.405000; val_acc: 0.322000
(Iteration 121 / 200) loss: 1.697994
(Iteration 131 / 200) loss: 1.768837
(Iteration 141 / 200) loss: 1.784967
(Iteration 151 / 200) loss: 1.823291
(Epoch 4 / 5) train acc: 0.431000; val_acc: 0.324000
(Iteration 161 / 200) loss: 1.626499
(Iteration 171 / 200) loss: 1.901366
(Iteration 181 / 200) loss: 1.549513
(Iteration 191 / 200) loss: 1.712569
(Epoch 5 / 5) train acc: 0.431000; val_acc: 0.330000
running with sgd_momentum
(Iteration 1 / 200) loss: 3.153778
(Epoch 0 / 5) train acc: 0.105000; val_acc: 0.093000
(Iteration 11 / 200) loss: 2.145874
(Iteration 21 / 200) loss: 2.032563
(Iteration 31 / 200) loss: 1.985848
(Epoch 1 / 5) train acc: 0.311000; val_acc: 0.281000
(Iteration 41 / 200) loss: 1.882354
(Iteration 51 / 200) loss: 1.855372
(Iteration 61 / 200) loss: 1.649133
(Iteration 71 / 200) loss: 1.806432
(Epoch 2 / 5) train acc: 0.415000; val_acc: 0.324000
(Iteration 81 / 200) loss: 1.907840
(Iteration 91 / 200) loss: 1.510681
(Iteration 101 / 200) loss: 1.546872
(Iteration 111 / 200) loss: 1.512047
(Epoch 3 / 5) train acc: 0.434000; val_acc: 0.321000
(Iteration 121 / 200) loss: 1.677301
(Iteration 131 / 200) loss: 1.504686
(Iteration 141 / 200) loss: 1.633253
(Iteration 151 / 200) loss: 1.745081
(Epoch 4 / 5) train acc: 0.460000; val_acc: 0.353000
(Iteration 161 / 200) loss: 1.485411
(Iteration 171 / 200) loss: 1.610416
(Iteration 181 / 200) loss: 1.528331
(Iteration 191 / 200) loss: 1.447239
(Epoch 5 / 5) train acc: 0.515000; val_acc: 0.384000
| MIT | practice4/FullyConnectedNets_plus_bonus.ipynb | enliktjioe/nn2020 |
RMSProp and AdamRMSProp [1] and Adam [2] are update rules that set per-parameter learning rates by using a running average of the second moments of gradients.**Task 2.5.2 (4pts):** In the file `optim.py`, implement the RMSProp update rule in the `rmsprop` function and implement the Adam update rule in the `adam` function, and check your implementations using the tests below.[1] Tijmen Tieleman and Geoffrey Hinton. "Lecture 6.5-rmsprop: Divide the gradient by a running average of its recent magnitude." COURSERA: Neural Networks for Machine Learning 4 (2012).[2] Diederik Kingma and Jimmy Ba, "Adam: A Method for Stochastic Optimization", ICLR 2015. | # Test RMSProp implementation; you should see errors less than 1e-7
from optim import rmsprop
N, D = 4, 5
w = np.linspace(-0.4, 0.6, num=N*D).reshape(N, D)
dw = np.linspace(-0.6, 0.4, num=N*D).reshape(N, D)
cache = np.linspace(0.6, 0.9, num=N*D).reshape(N, D)
config = {'learning_rate': 1e-2, 'cache': cache}
next_w, _ = rmsprop(w, dw, config=config)
expected_next_w = np.asarray([
[-0.39223849, -0.34037513, -0.28849239, -0.23659121, -0.18467247],
[-0.132737, -0.08078555, -0.02881884, 0.02316247, 0.07515774],
[ 0.12716641, 0.17918792, 0.23122175, 0.28326742, 0.33532447],
[ 0.38739248, 0.43947102, 0.49155973, 0.54365823, 0.59576619]])
expected_cache = np.asarray([
[ 0.5976, 0.6126277, 0.6277108, 0.64284931, 0.65804321],
[ 0.67329252, 0.68859723, 0.70395734, 0.71937285, 0.73484377],
[ 0.75037008, 0.7659518, 0.78158892, 0.79728144, 0.81302936],
[ 0.82883269, 0.84469141, 0.86060554, 0.87657507, 0.8926 ]])
print('next_w error: ', rel_error(expected_next_w, next_w))
print('cache error: ', rel_error(expected_cache, config['cache']))
# Test Adam implementation; you should see errors around 1e-7 or less
from optim import adam
N, D = 4, 5
w = np.linspace(-0.4, 0.6, num=N*D).reshape(N, D)
dw = np.linspace(-0.6, 0.4, num=N*D).reshape(N, D)
m = np.linspace(0.6, 0.9, num=N*D).reshape(N, D)
v = np.linspace(0.7, 0.5, num=N*D).reshape(N, D)
config = {'learning_rate': 1e-2, 'm': m, 'v': v, 't': 5}
next_w, _ = adam(w, dw, config=config)
#print(next_w)
#print(config)
expected_next_w = np.asarray([
[-0.40094747, -0.34836187, -0.29577703, -0.24319299, -0.19060977],
[-0.1380274, -0.08544591, -0.03286534, 0.01971428, 0.0722929],
[ 0.1248705, 0.17744702, 0.23002243, 0.28259667, 0.33516969],
[ 0.38774145, 0.44031188, 0.49288093, 0.54544852, 0.59801459]])
expected_v = np.asarray([
[ 0.69966, 0.68908382, 0.67851319, 0.66794809, 0.65738853,],
[ 0.64683452, 0.63628604, 0.6257431, 0.61520571, 0.60467385,],
[ 0.59414753, 0.58362676, 0.57311152, 0.56260183, 0.55209767,],
[ 0.54159906, 0.53110598, 0.52061845, 0.51013645, 0.49966, ]])
expected_m = np.asarray([
[ 0.48, 0.49947368, 0.51894737, 0.53842105, 0.55789474],
[ 0.57736842, 0.59684211, 0.61631579, 0.63578947, 0.65526316],
[ 0.67473684, 0.69421053, 0.71368421, 0.73315789, 0.75263158],
[ 0.77210526, 0.79157895, 0.81105263, 0.83052632, 0.85 ]])
print('next_w error: ', rel_error(expected_next_w, next_w))
print('v error: ', rel_error(expected_v, config['v']))
print('m error: ', rel_error(expected_m, config['m'])) | next_w error: 1.1395691798535431e-07
v error: 4.208314038113071e-09
m error: 4.214963193114416e-09
| MIT | practice4/FullyConnectedNets_plus_bonus.ipynb | enliktjioe/nn2020 |
Once you have debugged your RMSProp and Adam implementations, run the following to train a pair of deep networks using these new update rules: | learning_rates = {'rmsprop': 1e-4, 'adam': 1e-3}
for update_rule in ['adam', 'rmsprop']:
print('running with ', update_rule)
model = FullyConnectedNet([100, 100, 100, 100, 100], weight_scale=5e-2)
solver = Solver(model, small_data,
num_epochs=5, batch_size=100,
update_rule=update_rule,
optim_config={'learning_rate': learning_rates[update_rule]},
verbose=True)
solvers[update_rule] = solver
solver.train()
print()
plt.subplot(3, 1, 1)
plt.title('Training loss')
plt.xlabel('Iteration')
plt.subplot(3, 1, 2)
plt.title('Training accuracy')
plt.xlabel('Epoch')
plt.subplot(3, 1, 3)
plt.title('Validation accuracy')
plt.xlabel('Epoch')
for update_rule, solver in list(solvers.items()):
plt.subplot(3, 1, 1)
plt.plot(solver.loss_history, 'o', label=update_rule)
plt.subplot(3, 1, 2)
plt.plot(solver.train_acc_history, '-o', label=update_rule)
plt.subplot(3, 1, 3)
plt.plot(solver.val_acc_history, '-o', label=update_rule)
for i in [1, 2, 3]:
plt.subplot(3, 1, i)
plt.legend(loc='upper center', ncol=4)
plt.gcf().set_size_inches(15, 15)
plt.show() | running with adam
(Iteration 1 / 200) loss: 3.476928
(Epoch 0 / 5) train acc: 0.143000; val_acc: 0.114000
(Iteration 11 / 200) loss: 2.089203
(Iteration 21 / 200) loss: 2.211850
(Iteration 31 / 200) loss: 1.786014
(Epoch 1 / 5) train acc: 0.393000; val_acc: 0.340000
(Iteration 41 / 200) loss: 1.743813
(Iteration 51 / 200) loss: 1.752164
(Iteration 61 / 200) loss: 2.095686
(Iteration 71 / 200) loss: 1.489003
(Epoch 2 / 5) train acc: 0.411000; val_acc: 0.357000
(Iteration 81 / 200) loss: 1.546641
(Iteration 91 / 200) loss: 1.412224
(Iteration 101 / 200) loss: 1.401821
(Iteration 111 / 200) loss: 1.521807
(Epoch 3 / 5) train acc: 0.494000; val_acc: 0.368000
(Iteration 121 / 200) loss: 1.237183
(Iteration 131 / 200) loss: 1.466022
(Iteration 141 / 200) loss: 1.284994
(Iteration 151 / 200) loss: 1.466689
(Epoch 4 / 5) train acc: 0.529000; val_acc: 0.383000
(Iteration 161 / 200) loss: 1.405442
(Iteration 171 / 200) loss: 1.270982
(Iteration 181 / 200) loss: 1.276394
(Iteration 191 / 200) loss: 1.170272
(Epoch 5 / 5) train acc: 0.582000; val_acc: 0.375000
running with rmsprop
(Iteration 1 / 200) loss: 2.589166
(Epoch 0 / 5) train acc: 0.119000; val_acc: 0.146000
(Iteration 11 / 200) loss: 2.039570
(Iteration 21 / 200) loss: 1.897350
(Iteration 31 / 200) loss: 1.763338
(Epoch 1 / 5) train acc: 0.382000; val_acc: 0.326000
(Iteration 41 / 200) loss: 1.893851
(Iteration 51 / 200) loss: 1.715673
(Iteration 61 / 200) loss: 1.473092
(Iteration 71 / 200) loss: 1.602196
(Epoch 2 / 5) train acc: 0.434000; val_acc: 0.341000
(Iteration 81 / 200) loss: 1.501205
(Iteration 91 / 200) loss: 1.629006
(Iteration 101 / 200) loss: 1.516101
(Iteration 111 / 200) loss: 1.555156
(Epoch 3 / 5) train acc: 0.469000; val_acc: 0.362000
(Iteration 121 / 200) loss: 1.508093
(Iteration 131 / 200) loss: 1.543763
(Iteration 141 / 200) loss: 1.537697
(Iteration 151 / 200) loss: 1.698558
(Epoch 4 / 5) train acc: 0.518000; val_acc: 0.367000
(Iteration 161 / 200) loss: 1.596201
(Iteration 171 / 200) loss: 1.451059
(Iteration 181 / 200) loss: 1.526125
(Iteration 191 / 200) loss: 1.354783
(Epoch 5 / 5) train acc: 0.523000; val_acc: 0.370000
| MIT | practice4/FullyConnectedNets_plus_bonus.ipynb | enliktjioe/nn2020 |
Train a good model!**Task 2.6 (2pts):** Train the best fully-connected model that you can on CIFAR-10, storing your best model in the `best_model` variable. We require you to get at least 50% accuracy on the validation set using a fully-connected net.If you are careful it should be possible to get accuracies above 55%, but we don't require it for this part and won't assign extra credit for doing so. Later in the assignment we will ask you to train the best convolutional network that you can on CIFAR-10, and we would prefer that you spend your effort working on convolutional nets rather than fully-connected nets.**Bonus points:** You might find it useful to complete the `Dropout.ipynb` notebook before completing this part, since this technique can help you train powerful models. | best_model = None
################################################################################
# TODO: Train the best FullyConnectedNet that you can on CIFAR-10. You might #
# batch normalization and dropout useful. Store your best model in the #
# best_model variable. #
################################################################################
results={}
best_val=-1
learning_rate=[3e-4]#[1e-2,1e-3,1e-4]#[2e-2,2e-3,2e-4]#[3e-2,3e-3,3e-4]
weight_scale= [2.5e-2] #[1e-3,1e-2,1e-3]#[2e-2,2e-3,2e-4]
dropouts=[0.9]#[0.5,0.6,0.7]#[0.7,0.8,0.9]
#Loop through different learning rates
for i in learning_rate:
#Loop through different weight_scales
for j in weight_scale:
#Loop through different dropout probabilites
for k in dropouts:
print('Running: Learning rate: %e Weight scale: %e Dropout: %e'%(i,j,k) )
#Set up the model accordingly
model = FullyConnectedNet([100, 100, 100, 100, 100],dropout=k,weight_scale=j,reg=1e-2)
# Configure the solver
solver = Solver(model, data,lr_decay=0.9,
num_epochs=10, batch_size=30,
update_rule='adam',
optim_config={'learning_rate': i,},
verbose=True,print_every=400)
# Train the model
solver.train()
#Fetch last training & validation accuracy
validation_accuracy=solver.val_acc_history[-1]
training_accuracy=solver.train_acc_history[-1]
#Store results in a container
results[(i,j,k)]=training_accuracy,validation_accuracy
# Once validation accuracy is higher than current bes
if best_val <validation_accuracy:
# Update best validatioin accuracy
best_val = validation_accuracy
# Update best network
best_model=model
print('Done. Training Accuracy: %f, Validation Accuracy: %f'%(training_accuracy,validation_accuracy))
#Loop to print out the results of above loop
for i,j,k in sorted(results):
train_accuracy,val_accuracy=results[(i,j,k)]
print ('Learning rate: %e Weight scale: %e Dropout: %e Train accuracy: %f, Validation accuracy: %f' % (i, j, k, train_accuracy, val_accuracy))
################################################################################
# END OF YOUR CODE #
################################################################################ | Running: Learning rate: 3.000000e-04 Weight scale: 2.500000e-02 Dropout: 9.000000e-01
(Iteration 1 / 16330) loss: 3.387063
(Epoch 0 / 10) train acc: 0.080000; val_acc: 0.112000
(Iteration 401 / 16330) loss: 2.038029
(Iteration 801 / 16330) loss: 1.914008
(Iteration 1201 / 16330) loss: 1.880346
(Iteration 1601 / 16330) loss: 1.596147
(Epoch 1 / 10) train acc: 0.400000; val_acc: 0.423000
(Iteration 2001 / 16330) loss: 1.896053
(Iteration 2401 / 16330) loss: 1.877945
(Iteration 2801 / 16330) loss: 1.560352
(Iteration 3201 / 16330) loss: 2.113439
(Epoch 2 / 10) train acc: 0.408000; val_acc: 0.442000
(Iteration 3601 / 16330) loss: 1.822949
(Iteration 4001 / 16330) loss: 1.929417
(Iteration 4401 / 16330) loss: 1.643511
(Iteration 4801 / 16330) loss: 1.736321
(Epoch 3 / 10) train acc: 0.452000; val_acc: 0.463000
(Iteration 5201 / 16330) loss: 2.089003
(Iteration 5601 / 16330) loss: 1.506891
(Iteration 6001 / 16330) loss: 1.577858
(Iteration 6401 / 16330) loss: 1.657605
(Epoch 4 / 10) train acc: 0.485000; val_acc: 0.483000
(Iteration 6801 / 16330) loss: 1.571448
(Iteration 7201 / 16330) loss: 1.704583
(Iteration 7601 / 16330) loss: 1.844080
(Iteration 8001 / 16330) loss: 1.733486
(Epoch 5 / 10) train acc: 0.494000; val_acc: 0.480000
(Iteration 8401 / 16330) loss: 1.687219
(Iteration 8801 / 16330) loss: 1.390158
(Iteration 9201 / 16330) loss: 1.390699
(Iteration 9601 / 16330) loss: 1.415803
(Epoch 6 / 10) train acc: 0.494000; val_acc: 0.505000
(Iteration 10001 / 16330) loss: 1.792690
(Iteration 10401 / 16330) loss: 1.637958
(Iteration 10801 / 16330) loss: 1.797944
(Iteration 11201 / 16330) loss: 1.634449
(Epoch 7 / 10) train acc: 0.502000; val_acc: 0.484000
(Iteration 11601 / 16330) loss: 1.628916
(Iteration 12001 / 16330) loss: 1.255021
(Iteration 12401 / 16330) loss: 1.501996
(Iteration 12801 / 16330) loss: 1.493511
(Epoch 8 / 10) train acc: 0.528000; val_acc: 0.487000
(Iteration 13201 / 16330) loss: 1.707115
(Iteration 13601 / 16330) loss: 1.516169
(Iteration 14001 / 16330) loss: 1.760193
(Iteration 14401 / 16330) loss: 1.548953
(Epoch 9 / 10) train acc: 0.525000; val_acc: 0.501000
(Iteration 14801 / 16330) loss: 1.240440
(Iteration 15201 / 16330) loss: 1.240159
(Iteration 15601 / 16330) loss: 1.385997
(Iteration 16001 / 16330) loss: 1.736534
(Epoch 10 / 10) train acc: 0.571000; val_acc: 0.507000
Done. Training Accuracy: 0.571000, Validation Accuracy: 0.507000
Learning rate: 3.000000e-04 Weight scale: 2.500000e-02 Dropout: 9.000000e-01 Train accuracy: 0.571000, Validation accuracy: 0.507000
| MIT | practice4/FullyConnectedNets_plus_bonus.ipynb | enliktjioe/nn2020 |
Test your modelRun your best model on the validation and test sets. You should achieve above 50% accuracy on the validation set. | y_test_pred = np.argmax(best_model.loss(data['X_test']), axis=1)
y_val_pred = np.argmax(best_model.loss(data['X_val']), axis=1)
print('Validation set accuracy: ', (y_val_pred == data['y_val']).mean())
print('Test set accuracy: ', (y_test_pred == data['y_test']).mean()) | Validation set accuracy: 0.507
Test set accuracy: 0.516
| MIT | practice4/FullyConnectedNets_plus_bonus.ipynb | enliktjioe/nn2020 |
 [](https://colab.research.google.com/github/JohnSnowLabs/spark-nlp-workshop/blob/master/tutorials/Certification_Trainings/Healthcare/16.Adverse_Drug_Event_ADE_NER_and_Classifier.ipynb) Adverse Drug Event (ADE) Pretrained NER and Classifier Models `ADE NER`: Extracts ADE and DRUG entities from clinical texts.`ADE Classifier`: CLassify if a sentence is ADE-related (`True`) or not (`False`)We use several datasets to train these models:- Twitter dataset, which is used in paper "`Deep learning for pharmacovigilance: recurrent neural network architectures for labeling adverse drug reactions in Twitter posts`" (https://pubmed.ncbi.nlm.nih.gov/28339747/)- ADE-Corpus-V2, which is used in paper "`An Attentive Sequence Model for Adverse Drug Event Extraction from Biomedical Text`" (https://arxiv.org/abs/1801.00625) and availe online: https://sites.google.com/site/adecorpus/home/document.- CADEC dataset, which is sued in paper `Cadec: A corpus of adverse drug event annotations` (https://pubmed.ncbi.nlm.nih.gov/25817970) | import json
from google.colab import files
license_keys = files.upload()
with open(list(license_keys.keys())[0]) as f:
license_keys = json.load(f)
license_keys.keys()
import os
# Install java
! apt-get update -qq
! apt-get install -y openjdk-8-jdk-headless -qq > /dev/null
os.environ["JAVA_HOME"] = "/usr/lib/jvm/java-8-openjdk-amd64"
os.environ["PATH"] = os.environ["JAVA_HOME"] + "/bin:" + os.environ["PATH"]
! java -version
secret = license_keys['SECRET']
os.environ['SPARK_NLP_LICENSE'] = license_keys['SPARK_NLP_LICENSE']
os.environ['AWS_ACCESS_KEY_ID']= license_keys['AWS_ACCESS_KEY_ID']
os.environ['AWS_SECRET_ACCESS_KEY'] = license_keys['AWS_SECRET_ACCESS_KEY']
version = license_keys['PUBLIC_VERSION']
jsl_version = license_keys['JSL_VERSION']
! pip install --ignore-installed -q pyspark==2.4.4
! python -m pip install --upgrade spark-nlp-jsl==$jsl_version --extra-index-url https://pypi.johnsnowlabs.com/$secret
! pip install --ignore-installed -q spark-nlp==$version
import sparknlp
print (sparknlp.version())
import json
import os
from pyspark.ml import Pipeline
from pyspark.sql import SparkSession
from sparknlp.annotator import *
from sparknlp_jsl.annotator import *
from sparknlp.base import *
import sparknlp_jsl
spark = sparknlp_jsl.start(secret)
print (sparknlp.version()) | 2.6.2
| Apache-2.0 | tutorials/Certification_Trainings/Healthcare/16.Adverse_Drug_Event_ADE_NER_and_Classifier.ipynb | ewbolme/spark-nlp-workshop |
ADE Classifier Pipeline (with a pretrained model)`True` : The sentence is talking about a possible ADE`False` : The sentences doesn't have any information about an ADE. ADE Classifier with BioBert  | # Annotator that transforms a text column from dataframe into an Annotation ready for NLP
documentAssembler = DocumentAssembler()\
.setInputCol("text")\
.setOutputCol("sentence")
# Tokenizer splits words in a relevant format for NLP
tokenizer = Tokenizer()\
.setInputCols(["sentence"])\
.setOutputCol("token")
bert_embeddings = BertEmbeddings.pretrained("biobert_pubmed_base_cased")\
.setInputCols(["sentence", "token"])\
.setOutputCol("embeddings")\
.setMaxSentenceLength(512)
embeddingsSentence = SentenceEmbeddings() \
.setInputCols(["sentence", "embeddings"]) \
.setOutputCol("sentence_embeddings") \
.setPoolingStrategy("AVERAGE")\
.setStorageRef('biobert_pubmed_base_cased')
classsifierdl = ClassifierDLModel.pretrained("classifierdl_ade_biobert", "en", "clinical/models")\
.setInputCols(["sentence", "sentence_embeddings"]) \
.setOutputCol("class")
ade_clf_pipeline = Pipeline(
stages=[documentAssembler,
tokenizer,
bert_embeddings,
embeddingsSentence,
classsifierdl])
empty_data = spark.createDataFrame([[""]]).toDF("text")
ade_clf_model = ade_clf_pipeline.fit(empty_data)
ade_lp_pipeline = LightPipeline(ade_clf_model)
text = "I feel a bit drowsy & have a little blurred vision after taking an insulin"
ade_lp_pipeline.annotate(text)['class'][0]
text="I just took an Advil and have no gastric problems so far."
ade_lp_pipeline.annotate(text)['class'][0] | _____no_output_____ | Apache-2.0 | tutorials/Certification_Trainings/Healthcare/16.Adverse_Drug_Event_ADE_NER_and_Classifier.ipynb | ewbolme/spark-nlp-workshop |
as you see `gastric problems` is not detected as `ADE` as it is in a negative context. So, classifier did a good job detecting that. | text="I just took a Metformin and started to feel dizzy."
ade_lp_pipeline.annotate(text)['class'][0]
t='''
Always tired, and possible blood clots. I was on Voltaren for about 4 years and all of the sudden had a minor stroke and had blood clots that traveled to my eye. I had every test in the book done at the hospital, and they couldnt find anything. I was completley healthy! I am thinking it was from the voltaren. I have been off of the drug for 8 months now, and have never felt better. I started eating healthy and working out and that has help alot. I can now sleep all thru the night. I wont take this again. If I have the back pain, I will pop a tylonol instead.
'''
ade_lp_pipeline.annotate(t)['class'][0]
texts = ["I feel a bit drowsy & have a little blurred vision, after taking a pill.",
"I've been on Arthrotec 50 for over 10 years on and off, only taking it when I needed it.",
"Due to my arthritis getting progressively worse, to the point where I am in tears with the agony, gp's started me on 75 twice a day and I have to take it every day for the next month to see how I get on, here goes.",
"So far its been very good, pains almost gone, but I feel a bit weird, didn't have that when on 50."]
for text in texts:
result = ade_lp_pipeline.annotate(text)
print (result['class'][0])
| True
False
True
False
| Apache-2.0 | tutorials/Certification_Trainings/Healthcare/16.Adverse_Drug_Event_ADE_NER_and_Classifier.ipynb | ewbolme/spark-nlp-workshop |
ADE Classifier trained with conversational (short) sentences This model is trained on short, conversational sentences related to ADE and is supposed to do better on the text that is short and used in a daily context.  |
conv_classsifierdl = ClassifierDLModel.pretrained("classifierdl_ade_conversational_biobert", "en", "clinical/models")\
.setInputCols(["sentence", "sentence_embeddings"]) \
.setOutputCol("class")
conv_ade_clf_pipeline = Pipeline(
stages=[documentAssembler,
tokenizer,
bert_embeddings,
embeddingsSentence,
conv_classsifierdl])
empty_data = spark.createDataFrame([[""]]).toDF("text")
conv_ade_clf_model = conv_ade_clf_pipeline.fit(empty_data)
conv_ade_lp_pipeline = LightPipeline(conv_ade_clf_model)
text = "after taking a pill, he denies any pain"
conv_ade_lp_pipeline.annotate(text)['class'][0] | _____no_output_____ | Apache-2.0 | tutorials/Certification_Trainings/Healthcare/16.Adverse_Drug_Event_ADE_NER_and_Classifier.ipynb | ewbolme/spark-nlp-workshop |
ADE NERExtracts `ADE` and `DRUG` entities from text.  | documentAssembler = DocumentAssembler()\
.setInputCol("text")\
.setOutputCol("document")
sentenceDetector = SentenceDetector()\
.setInputCols(["document"])\
.setOutputCol("sentence")
tokenizer = Tokenizer()\
.setInputCols(["sentence"])\
.setOutputCol("token")
word_embeddings = WordEmbeddingsModel.pretrained("embeddings_clinical", "en", "clinical/models")\
.setInputCols(["sentence", "token"])\
.setOutputCol("embeddings")
ade_ner = NerDLModel.pretrained("ner_ade_clinical", "en", "clinical/models") \
.setInputCols(["sentence", "token", "embeddings"]) \
.setOutputCol("ner")
ner_converter = NerConverter() \
.setInputCols(["sentence", "token", "ner"]) \
.setOutputCol("ner_chunk")
ner_pipeline = Pipeline(stages=[
documentAssembler,
sentenceDetector,
tokenizer,
word_embeddings,
ade_ner,
ner_converter])
empty_data = spark.createDataFrame([[""]]).toDF("text")
ade_ner_model = ner_pipeline.fit(empty_data)
ade_ner_lp = LightPipeline(ade_ner_model)
light_result = ade_ner_lp.fullAnnotate("I feel a bit drowsy & have a little blurred vision, so far no gastric problems. I have been on Arthrotec 50 for over 10 years on and off, only taking it when I needed it. Due to my arthritis getting progressively worse, to the point where I am in tears with the agony, gp's started me on 75 twice a day and I have to take it every day for the next month to see how I get on, here goes. So far its been very good, pains almost gone, but I feel a bit weird, didn't have that when on 50.")
chunks = []
entities = []
begin =[]
end = []
for n in light_result[0]['ner_chunk']:
begin.append(n.begin)
end.append(n.end)
chunks.append(n.result)
entities.append(n.metadata['entity'])
import pandas as pd
df = pd.DataFrame({'chunks':chunks, 'entities':entities,
'begin': begin, 'end': end})
df | _____no_output_____ | Apache-2.0 | tutorials/Certification_Trainings/Healthcare/16.Adverse_Drug_Event_ADE_NER_and_Classifier.ipynb | ewbolme/spark-nlp-workshop |
as you see `gastric problems` is not detected as `ADE` as it is in a negative context. So, NER did a good job ignoring that. ADE NER with Bert embeddings  | documentAssembler = DocumentAssembler()\
.setInputCol("text")\
.setOutputCol("document")
sentenceDetector = SentenceDetector()\
.setInputCols(["document"])\
.setOutputCol("sentence")
tokenizer = Tokenizer()\
.setInputCols(["sentence"])\
.setOutputCol("token")
bert_embeddings = BertEmbeddings.pretrained("biobert_pubmed_base_cased")\
.setInputCols(["sentence", "token"])\
.setOutputCol("embeddings")
ade_ner_bert = NerDLModel.pretrained("ner_ade_biobert", "en", "clinical/models") \
.setInputCols(["sentence", "token", "embeddings"]) \
.setOutputCol("ner")
ner_converter = NerConverter() \
.setInputCols(["sentence", "token", "ner"]) \
.setOutputCol("ner_chunk")
ner_pipeline = Pipeline(stages=[
documentAssembler,
sentenceDetector,
tokenizer,
bert_embeddings,
ade_ner_bert,
ner_converter])
empty_data = spark.createDataFrame([[""]]).toDF("text")
ade_ner_model_bert = ner_pipeline.fit(empty_data)
ade_ner_lp_bert = LightPipeline(ade_ner_model_bert)
light_result = ade_ner_lp_bert.fullAnnotate("I feel a bit drowsy & have a little blurred vision, so far no gastric problems. I have been on Arthrotec 50 for over 10 years on and off, only taking it when I needed it. Due to my arthritis getting progressively worse, to the point where I am in tears with the agony, gp's started me on 75 twice a day and I have to take it every day for the next month to see how I get on, here goes. So far its been very good, pains almost gone, but I feel a bit weird, didn't have that when on 50.")
chunks = []
entities = []
begin =[]
end = []
for n in light_result[0]['ner_chunk']:
begin.append(n.begin)
end.append(n.end)
chunks.append(n.result)
entities.append(n.metadata['entity'])
import pandas as pd
df = pd.DataFrame({'chunks':chunks, 'entities':entities,
'begin': begin, 'end': end})
df | _____no_output_____ | Apache-2.0 | tutorials/Certification_Trainings/Healthcare/16.Adverse_Drug_Event_ADE_NER_and_Classifier.ipynb | ewbolme/spark-nlp-workshop |
Looks like Bert version of NER returns more entities than clinical embeddings version. NER and Classifier combined with AssertionDL Model | assertion_ner_converter = NerConverter() \
.setInputCols(["sentence", "token", "ner"]) \
.setOutputCol("ass_ner_chunk")\
.setWhiteList(['ADE'])
biobert_assertion = AssertionDLModel.pretrained("assertiondl_biobert", "en", "clinical/models") \
.setInputCols(["sentence", "ass_ner_chunk", "embeddings"]) \
.setOutputCol("assertion")
assertion_ner_pipeline = Pipeline(stages=[
documentAssembler,
sentenceDetector,
tokenizer,
bert_embeddings,
ade_ner_bert,
ner_converter,
assertion_ner_converter,
biobert_assertion])
empty_data = spark.createDataFrame([[""]]).toDF("text")
ade_ass_ner_model_bert = assertion_ner_pipeline.fit(empty_data)
ade_ass_ner_model_lp_bert = LightPipeline(ade_ass_ner_model_bert)
import pandas as pd
text = "I feel a bit drowsy & have a little blurred vision, so far no gastric problems. I have been on Arthrotec 50 for over 10 years on and off, only taking it when I needed it. Due to my arthritis getting progressively worse, to the point where I am in tears with the agony, gp's started me on 75 twice a day and I have to take it every day for the next month to see how I get on, here goes. So far its been very good, pains almost gone, but I feel a bit weird, didn't have that when on 50."
print (text)
light_result = ade_ass_ner_model_lp_bert.fullAnnotate(text)[0]
chunks=[]
entities=[]
status=[]
for n,m in zip(light_result['ass_ner_chunk'],light_result['assertion']):
chunks.append(n.result)
entities.append(n.metadata['entity'])
status.append(m.result)
df = pd.DataFrame({'chunks':chunks, 'entities':entities, 'assertion':status})
df | I feel a bit drowsy & have a little blurred vision, so far no gastric problems. I have been on Arthrotec 50 for over 10 years on and off, only taking it when I needed it. Due to my arthritis getting progressively worse, to the point where I am in tears with the agony, gp's started me on 75 twice a day and I have to take it every day for the next month to see how I get on, here goes. So far its been very good, pains almost gone, but I feel a bit weird, didn't have that when on 50.
| Apache-2.0 | tutorials/Certification_Trainings/Healthcare/16.Adverse_Drug_Event_ADE_NER_and_Classifier.ipynb | ewbolme/spark-nlp-workshop |
Looks great ! `gastric problems` is detected as `ADE` and `absent` ADE models applied to Spark Dataframes | import pyspark.sql.functions as F
! wget -q https://raw.githubusercontent.com/JohnSnowLabs/spark-nlp-workshop/master/tutorials/Certification_Trainings/Healthcare/data/sample_ADE_dataset.csv
ade_DF = spark.read\
.option("header", "true")\
.csv("./sample_ADE_dataset.csv")\
.filter(F.col("label").isin(['True','False']))
ade_DF.show(truncate=50) | +--------------------------------------------------+-----+
| text|label|
+--------------------------------------------------+-----+
|Do U know what Meds are R for bipolar depressio...|False|
|# hypercholesterol: Because of elevated CKs (pe...| True|
|Her weight, respirtory status and I/O should be...|False|
|* DM - Pt had several episodes of hypoglycemia ...| True|
|We report the case of a female acromegalic pati...| True|
|2 . Calcipotriene 0.005% Cream Sig: One (1) App...|False|
|Always tired, and possible blood clots. I was o...| True|
|A difference in chemical structure between thes...|False|
|10 . She was left on prednisone 20mg qd due to ...|False|
|The authors suggest that risperidone may increa...| True|
|- Per oral maxillofacial surgery there is no ev...|False|
|@marionjross Cipro is just as bad! Stay away fr...|False|
|A young woman with epilepsy had tonic-clonic se...| True|
|Intravenous methotrexate is an effective adjunc...|False|
|PURPOSE: To report new indocyanine green angiog...|False|
|2 . Docusate Sodium 50 mg/5 mL Liquid [**Hospit...|False|
| consider neupogen.|False|
|He was treated allopurinol and Rasburicase for ...|False|
|Toxicity, pharmacokinetics, and in vitro hemodi...| True|
|# thrombocytopenia: Secondary to chemotherapy a...| True|
+--------------------------------------------------+-----+
only showing top 20 rows
| Apache-2.0 | tutorials/Certification_Trainings/Healthcare/16.Adverse_Drug_Event_ADE_NER_and_Classifier.ipynb | ewbolme/spark-nlp-workshop |
**With BioBert version of NER** (will be slower but more accurate) | import pyspark.sql.functions as F
ner_converter = NerConverter() \
.setInputCols(["sentence", "token", "ner"]) \
.setOutputCol("ner_chunk")\
.setWhiteList(['ADE'])
ner_pipeline = Pipeline(stages=[
documentAssembler,
sentenceDetector,
tokenizer,
bert_embeddings,
ade_ner_bert,
ner_converter])
empty_data = spark.createDataFrame([[""]]).toDF("text")
ade_ner_model = ner_pipeline.fit(empty_data)
result = ade_ner_model.transform(ade_DF)
sample_df = result.select('text','ner_chunk.result')\
.toDF('text','ADE_phrases').filter(F.size('ADE_phrases')>0).toPandas()
import pandas as pd
pd.set_option('display.max_colwidth', 0)
sample_df.sample(20) | _____no_output_____ | Apache-2.0 | tutorials/Certification_Trainings/Healthcare/16.Adverse_Drug_Event_ADE_NER_and_Classifier.ipynb | ewbolme/spark-nlp-workshop |
**Doing the same with clinical embeddings version** (faster results) | import pyspark.sql.functions as F
ner_converter = NerConverter() \
.setInputCols(["sentence", "token", "ner"]) \
.setOutputCol("ner_chunk")\
.setWhiteList(['ADE'])
ner_pipeline = Pipeline(stages=[
documentAssembler,
sentenceDetector,
tokenizer,
word_embeddings,
ade_ner,
ner_converter])
empty_data = spark.createDataFrame([[""]]).toDF("text")
ade_ner_model = ner_pipeline.fit(empty_data)
result = ade_ner_model.transform(ade_DF)
result.select('text','ner_chunk.result')\
.toDF('text','ADE_phrases').filter(F.size('ADE_phrases')>0)\
.show(truncate=70)
| +----------------------------------------------------------------------+----------------------------------------------------------------------+
| text| ADE_phrases|
+----------------------------------------------------------------------+----------------------------------------------------------------------+
|# hypercholesterol: Because of elevated CKs (peaked at 819) the pat...| [elevated CKs]|
|We report the case of a female acromegalic patient in whom multiple...| [multiple hepatic adenomas]|
|Always tired, and possible blood clots. I was on Voltaren for about...| [blood clots that traveled to my eye, back pain]|
|The authors suggest that risperidone may increase affect in patient...| [increase affect]|
|A young woman with epilepsy had tonic-clonic seizures during antine...| [tonic-clonic seizures]|
|Intravenous methotrexate is an effective adjunct to steroid therapy...| [dermatomyositis-polyositis]|
|PURPOSE: To report new indocyanine green angiographic (ICGA) findin...| [indocyanine green angiographic (ICGA) findings]|
|Toxicity, pharmacokinetics, and in vitro hemodialysis clearance of ...| [Toxicity]|
| # thrombocytopenia: Secondary to chemotherapy and MDS/AML concerns.| [thrombocytopenia]|
|A fatal massive pulmonary embolus developed in a patient treated wi...| [fatal massive pulmonary embolus]|
|# Maculopapular rash: over extremities, chest and back, thought [**...| [Maculopapular rash]|
| Hypokalemia after normal doses of neubulized albuterol (salbutamol).| [Hypokalemia]|
|A transient tonic pupillary response, denervation supersensitivity,...|[transient tonic pupillary response, denervation supersensitivity, ...|
|As per above, ID added Atovaquone for PCP [**Name9 (PRE) *] given t...| [BM suppression, liver damage]|
|Electrocardiographic findings and laboratory data indicated a diagn...| [acute myocardial infarction]|
| Hepatic reactions to cyclofenil.| [Hepatic reactions]|
|Therefore, parenteral amiodarone was implicated as the cause of acu...| [acute hepatitis]|
|Vincristine levels were also assayed and showed a dramatic decline ...| [dramatic decline in postexchange levels]|
|Eight days after the end of interferon treatment, he showed signs o...| [inability to sit]|
|2 years with no problems, then toe neuropathy for two years now and...|[toe neuropathy, toe neuropathy, stomach problems, pain, heart woul...|
+----------------------------------------------------------------------+----------------------------------------------------------------------+
only showing top 20 rows
| Apache-2.0 | tutorials/Certification_Trainings/Healthcare/16.Adverse_Drug_Event_ADE_NER_and_Classifier.ipynb | ewbolme/spark-nlp-workshop |
creating sentence dataframe (one sentence per row) and getting ADE entities and categories | documentAssembler = DocumentAssembler()\
.setInputCol("text")\
.setOutputCol("document")
sentenceDetector = SentenceDetector()\
.setInputCols(["document"])\
.setOutputCol("sentence")\
.setExplodeSentences(True)
tokenizer = Tokenizer()\
.setInputCols(["sentence"])\
.setOutputCol("token")
bert_embeddings = BertEmbeddings.pretrained("biobert_pubmed_base_cased")\
.setInputCols(["sentence", "token"])\
.setOutputCol("embeddings")
embeddingsSentence = SentenceEmbeddings() \
.setInputCols(["sentence", "embeddings"]) \
.setOutputCol("sentence_embeddings") \
.setPoolingStrategy("AVERAGE")\
.setStorageRef('biobert_pubmed_base_cased')
classsifierdl = ClassifierDLModel.pretrained("classifierdl_ade_biobert", "en", "clinical/models")\
.setInputCols(["sentence", "sentence_embeddings"]) \
.setOutputCol("class")\
.setStorageRef('biobert_pubmed_base_cased')
ade_ner = NerDLModel.pretrained("ner_ade_biobert", "en", "clinical/models") \
.setInputCols(["sentence", "token", "embeddings"]) \
.setOutputCol("ner")
ner_converter = NerConverter() \
.setInputCols(["sentence", "token", "ner"]) \
.setOutputCol("ner_chunk")\
.setWhiteList(['ADE'])
ner_clf_pipeline = Pipeline(
stages=[documentAssembler,
sentenceDetector,
tokenizer,
bert_embeddings,
embeddingsSentence,
classsifierdl,
ade_ner,
ner_converter])
ade_Sentences = ner_clf_pipeline.fit(ade_DF)
import pyspark.sql.functions as F
ade_Sentences.transform(ade_DF).select('sentence.result','ner_chunk.result','class.result')\
.toDF('sentence','ADE_phrases','is_ADE').show(truncate=60) | +------------------------------------------------------------+---------------------------------------------+-------+
| sentence| ADE_phrases| is_ADE|
+------------------------------------------------------------+---------------------------------------------+-------+
| [Do U know what Meds are R for bipolar depression?]| []|[False]|
| [Currently #FDA approved #quetiapine AKA #Seroquel]| []|[False]|
|[# hypercholesterol: Because of elevated CKs (peaked at 8...| [elevated CKs]|[False]|
|[Her weight, respirtory status and I/O should be monitore...| []|[False]|
|[* DM - Pt had several episodes of hypoglycemia on lantus...| [hypoglycemia]| [True]|
|[We report the case of a female acromegalic patient in wh...| [hepatic adenomas]| [True]|
| [2 .]| []|[False]|
|[Calcipotriene 0.005% Cream Sig: One (1) Appl Topical [**...| []|[False]|
| [Always tired, and possible blood clots.]| [tired, blood clots]|[False]|
|[I was on Voltaren for about 4 years and all of the sudde...|[stroke, blood clots that traveled to my eye]|[False]|
|[I had every test in the book done at the hospital, and t...| []|[False]|
| [I was completley healthy!]| [completley healthy]|[False]|
| [I am thinking it was from the voltaren.]| []|[False]|
|[I have been off of the drug for 8 months now, and have n...| []|[False]|
|[I started eating healthy and working out and that has he...| []|[False]|
| [I can now sleep all thru the night.]| []|[False]|
| [I wont take this again.]| []|[False]|
| [If I have the back pain, I will pop a tylonol instead.]| []|[False]|
|[A difference in chemical structure between these two dru...| []|[False]|
| [10 .]| []|[False]|
+------------------------------------------------------------+---------------------------------------------+-------+
only showing top 20 rows
| Apache-2.0 | tutorials/Certification_Trainings/Healthcare/16.Adverse_Drug_Event_ADE_NER_and_Classifier.ipynb | ewbolme/spark-nlp-workshop |
Creating a pretrained pipeline with ADE NER, Assertion and Classifer | # Annotator that transforms a text column from dataframe into an Annotation ready for NLP
documentAssembler = DocumentAssembler()\
.setInputCol("text")\
.setOutputCol("sentence")
# Tokenizer splits words in a relevant format for NLP
tokenizer = Tokenizer()\
.setInputCols(["sentence"])\
.setOutputCol("token")
bert_embeddings = BertEmbeddings.pretrained("biobert_pubmed_base_cased")\
.setInputCols(["sentence", "token"])\
.setOutputCol("embeddings")
ade_ner = NerDLModel.pretrained("ner_ade_biobert", "en", "clinical/models") \
.setInputCols(["sentence", "token", "embeddings"]) \
.setOutputCol("ner")\
.setStorageRef('biobert_pubmed_base_cased')
ner_converter = NerConverter() \
.setInputCols(["sentence", "token", "ner"]) \
.setOutputCol("ner_chunk")
assertion_ner_converter = NerConverter() \
.setInputCols(["sentence", "token", "ner"]) \
.setOutputCol("ass_ner_chunk")\
.setWhiteList(['ADE'])
biobert_assertion = AssertionDLModel.pretrained("assertiondl_biobert", "en", "clinical/models") \
.setInputCols(["sentence", "ass_ner_chunk", "embeddings"]) \
.setOutputCol("assertion")
embeddingsSentence = SentenceEmbeddings() \
.setInputCols(["sentence", "embeddings"]) \
.setOutputCol("sentence_embeddings") \
.setPoolingStrategy("AVERAGE")\
.setStorageRef('biobert_pubmed_base_cased')
classsifierdl = ClassifierDLModel.pretrained("classifierdl_ade_conversational_biobert", "en", "clinical/models")\
.setInputCols(["sentence", "sentence_embeddings"]) \
.setOutputCol("class")
ade_clf_pipeline = Pipeline(
stages=[documentAssembler,
tokenizer,
bert_embeddings,
ade_ner,
ner_converter,
assertion_ner_converter,
biobert_assertion,
embeddingsSentence,
classsifierdl])
empty_data = spark.createDataFrame([[""]]).toDF("text")
ade_ner_clf_model = ade_clf_pipeline.fit(empty_data)
ade_ner_clf_pipeline = LightPipeline(ade_ner_clf_model)
classsifierdl.getStorageRef()
text = 'Always tired, and possible blood clots. I was on Voltaren for about 4 years and all of the sudden had a minor stroke and had blood clots that traveled to my eye. I had every test in the book done at the hospital, and they couldnt find anything. I was completley healthy! I am thinking it was from the voltaren. I have been off of the drug for 8 months now, and have never felt better. I started eating healthy and working out and that has help alot. I can now sleep all thru the night. I wont take this again. If I have the back pain, I will pop a tylonol instead.'
light_result = ade_ner_clf_pipeline.fullAnnotate(text)
print (light_result[0]['class'][0].metadata)
chunks = []
entities = []
begin =[]
end = []
for n in light_result[0]['ner_chunk']:
begin.append(n.begin)
end.append(n.end)
chunks.append(n.result)
entities.append(n.metadata['entity'])
import pandas as pd
df = pd.DataFrame({'chunks':chunks, 'entities':entities,
'begin': begin, 'end': end})
df
import pandas as pd
text = 'I have always felt tired, but no blood clots. I was on Voltaren for about 4 years and all of the sudden had a minor stroke and had blood clots that traveled to my eye. I had every test in the book done at the hospital, and they couldnt find anything. I was completley healthy! I am thinking it was from the voltaren. I have been off of the drug for 8 months now, and have never felt better. I started eating healthy and working out and that has help alot. I can now sleep all thru the night. I wont take this again. If I have the back pain, I will pop a tylonol instead.'
print (text)
light_result = ade_ass_ner_model_lp_bert.fullAnnotate(text)[0]
chunks=[]
entities=[]
status=[]
for n,m in zip(light_result['ass_ner_chunk'],light_result['assertion']):
chunks.append(n.result)
entities.append(n.metadata['entity'])
status.append(m.result)
df = pd.DataFrame({'chunks':chunks, 'entities':entities, 'assertion':status})
df
result = ade_ner_clf_pipeline.annotate('I just took an Advil 100 mg and it made me drowsy')
print (result['class'])
print(list(zip(result['token'],result['ner'])))
ade_ner_clf_model.save('ade_pretrained_pipeline')
from sparknlp.pretrained import PretrainedPipeline
ade_pipeline = PretrainedPipeline.from_disk('ade_pretrained_pipeline')
ade_pipeline.annotate('I just took an Advil 100 mg and it made me drowsy') | _____no_output_____ | Apache-2.0 | tutorials/Certification_Trainings/Healthcare/16.Adverse_Drug_Event_ADE_NER_and_Classifier.ipynb | ewbolme/spark-nlp-workshop |
📝 Exercise M1.03The goal of this exercise is to compare the statistical performance of ourclassifier (81% accuracy) to some baseline classifiers that would ignore theinput data and instead make constant predictions.- What would be the score of a model that always predicts `' >50K'`?- What would be the score of a model that always predicts `' <=50K'`?- Is 81% or 82% accuracy a good score for this problem?Use a `DummyClassifier` and do a train-test split to evaluateits accuracy on the test set. This[link](https://scikit-learn.org/stable/modules/model_evaluation.htmldummy-estimators)shows a few examples of how to evaluate the statistical performance of thesebaseline models. | import pandas as pd
adult_census = pd.read_csv("../datasets/adult-census.csv") | _____no_output_____ | CC-BY-4.0 | notebooks/02_numerical_pipeline_ex_01.ipynb | ThomasBourgeois/scikit-learn-mooc |
We will first split our dataset to have the target separated from the dataused to train our predictive model. | target_name = "class"
target = adult_census[target_name]
data = adult_census.drop(columns=target_name) | _____no_output_____ | CC-BY-4.0 | notebooks/02_numerical_pipeline_ex_01.ipynb | ThomasBourgeois/scikit-learn-mooc |
We start by selecting only the numerical columns as seen in the previousnotebook. | numerical_columns = [
"age", "capital-gain", "capital-loss", "hours-per-week"]
data_numeric = data[numerical_columns] | _____no_output_____ | CC-BY-4.0 | notebooks/02_numerical_pipeline_ex_01.ipynb | ThomasBourgeois/scikit-learn-mooc |
Next, let's split the data and target into a train and test set. | from sklearn.model_selection import train_test_split
data_numeric_train, data_numeric_test, target_train, target_test = \
train_test_split(data_numeric, target, random_state=0)
from sklearn.model_selection import train_test_split
from sklearn.dummy import DummyClassifier
# Write your code here. | _____no_output_____ | CC-BY-4.0 | notebooks/02_numerical_pipeline_ex_01.ipynb | ThomasBourgeois/scikit-learn-mooc |
Attack Password with Timing Analysis (Preparation)Supported setups:SCOPES:* OPENADCPLATFORMS:* CWLITEXMEGA Basic setup for Chip-Whisperer Lite | SCOPETYPE = 'OPENADC'
PLATFORM = 'CWLITEXMEGA'
CRYPTO_TARGET = 'NONE' | _____no_output_____ | MIT | VM_Files/Mikrocontroller_1_Prepare.ipynb | stefanwitossek/securec_ws1920 |
Firmware Setup our `PLATFORM`, then build the firmware: | %%bash -s "$PLATFORM" "$CRYPTO_TARGET"
cd ../hardware/victims/firmware/Mikrocontroller_1
make PLATFORM=$1 CRYPTO_TARGET=$2 | rm -f -- basic-passwdcheck-CWLITEXMEGA.hex
rm -f -- basic-passwdcheck-CWLITEXMEGA.eep
rm -f -- basic-passwdcheck-CWLITEXMEGA.cof
rm -f -- basic-passwdcheck-CWLITEXMEGA.elf
rm -f -- basic-passwdcheck-CWLITEXMEGA.map
rm -f -- basic-passwdcheck-CWLITEXMEGA.sym
rm -f -- basic-passwdcheck-CWLITEXMEGA.lss
rm -f -- objdir/*.o
rm -f -- objdir/*.lst
rm -f -- basic-passwdcheck.s simpleserial.s XMEGA_AES_driver.s uart.s usart_driver.s xmega_hal.s
rm -f -- basic-passwdcheck.d simpleserial.d XMEGA_AES_driver.d uart.d usart_driver.d xmega_hal.d
rm -f -- basic-passwdcheck.i simpleserial.i XMEGA_AES_driver.i uart.i usart_driver.i xmega_hal.i
mkdir objdir
.
-------- begin --------
avr-gcc (GCC) 4.9.2
Copyright (C) 2014 Free Software Foundation, Inc.
This is free software; see the source for copying conditions. There is NO
warranty; not even for MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
.
Compiling C: basic-passwdcheck.c
avr-gcc -c -mmcu=atxmega128d3 -I. -fpack-struct -gdwarf-2 -DSS_VER=SS_VER_1_0 -DHAL_TYPE=HAL_xmega -DPLATFORM=CWLITEXMEGA -DF_CPU=7372800UL -Os -funsigned-char -funsigned-bitfields -fshort-enums -Wall -Wstrict-prototypes -Wa,-adhlns=objdir/basic-passwdcheck.lst -I.././simpleserial/ -I.././hal -I.././hal/xmega -I.././crypto/ -std=gnu99 -MMD -MP -MF .dep/basic-passwdcheck.o.d basic-passwdcheck.c -o objdir/basic-passwdcheck.o
.
Compiling C: .././simpleserial/simpleserial.c
avr-gcc -c -mmcu=atxmega128d3 -I. -fpack-struct -gdwarf-2 -DSS_VER=SS_VER_1_0 -DHAL_TYPE=HAL_xmega -DPLATFORM=CWLITEXMEGA -DF_CPU=7372800UL -Os -funsigned-char -funsigned-bitfields -fshort-enums -Wall -Wstrict-prototypes -Wa,-adhlns=objdir/simpleserial.lst -I.././simpleserial/ -I.././hal -I.././hal/xmega -I.././crypto/ -std=gnu99 -MMD -MP -MF .dep/simpleserial.o.d .././simpleserial/simpleserial.c -o objdir/simpleserial.o
.
Compiling C: .././hal/xmega/XMEGA_AES_driver.c
avr-gcc -c -mmcu=atxmega128d3 -I. -fpack-struct -gdwarf-2 -DSS_VER=SS_VER_1_0 -DHAL_TYPE=HAL_xmega -DPLATFORM=CWLITEXMEGA -DF_CPU=7372800UL -Os -funsigned-char -funsigned-bitfields -fshort-enums -Wall -Wstrict-prototypes -Wa,-adhlns=objdir/XMEGA_AES_driver.lst -I.././simpleserial/ -I.././hal -I.././hal/xmega -I.././crypto/ -std=gnu99 -MMD -MP -MF .dep/XMEGA_AES_driver.o.d .././hal/xmega/XMEGA_AES_driver.c -o objdir/XMEGA_AES_driver.o
.
Compiling C: .././hal/xmega/uart.c
avr-gcc -c -mmcu=atxmega128d3 -I. -fpack-struct -gdwarf-2 -DSS_VER=SS_VER_1_0 -DHAL_TYPE=HAL_xmega -DPLATFORM=CWLITEXMEGA -DF_CPU=7372800UL -Os -funsigned-char -funsigned-bitfields -fshort-enums -Wall -Wstrict-prototypes -Wa,-adhlns=objdir/uart.lst -I.././simpleserial/ -I.././hal -I.././hal/xmega -I.././crypto/ -std=gnu99 -MMD -MP -MF .dep/uart.o.d .././hal/xmega/uart.c -o objdir/uart.o
.
Compiling C: .././hal/xmega/usart_driver.c
avr-gcc -c -mmcu=atxmega128d3 -I. -fpack-struct -gdwarf-2 -DSS_VER=SS_VER_1_0 -DHAL_TYPE=HAL_xmega -DPLATFORM=CWLITEXMEGA -DF_CPU=7372800UL -Os -funsigned-char -funsigned-bitfields -fshort-enums -Wall -Wstrict-prototypes -Wa,-adhlns=objdir/usart_driver.lst -I.././simpleserial/ -I.././hal -I.././hal/xmega -I.././crypto/ -std=gnu99 -MMD -MP -MF .dep/usart_driver.o.d .././hal/xmega/usart_driver.c -o objdir/usart_driver.o
.
Compiling C: .././hal/xmega/xmega_hal.c
avr-gcc -c -mmcu=atxmega128d3 -I. -fpack-struct -gdwarf-2 -DSS_VER=SS_VER_1_0 -DHAL_TYPE=HAL_xmega -DPLATFORM=CWLITEXMEGA -DF_CPU=7372800UL -Os -funsigned-char -funsigned-bitfields -fshort-enums -Wall -Wstrict-prototypes -Wa,-adhlns=objdir/xmega_hal.lst -I.././simpleserial/ -I.././hal -I.././hal/xmega -I.././crypto/ -std=gnu99 -MMD -MP -MF .dep/xmega_hal.o.d .././hal/xmega/xmega_hal.c -o objdir/xmega_hal.o
.
Linking: basic-passwdcheck-CWLITEXMEGA.elf
avr-gcc -mmcu=atxmega128d3 -I. -fpack-struct -gdwarf-2 -DSS_VER=SS_VER_1_0 -DHAL_TYPE=HAL_xmega -DPLATFORM=CWLITEXMEGA -DF_CPU=7372800UL -Os -funsigned-char -funsigned-bitfields -fshort-enums -Wall -Wstrict-prototypes -Wa,-adhlns=objdir/basic-passwdcheck.o -I.././simpleserial/ -I.././hal -I.././hal/xmega -I.././crypto/ -std=gnu99 -MMD -MP -MF .dep/basic-passwdcheck-CWLITEXMEGA.elf.d objdir/basic-passwdcheck.o objdir/simpleserial.o objdir/XMEGA_AES_driver.o objdir/uart.o objdir/usart_driver.o objdir/xmega_hal.o --output basic-passwdcheck-CWLITEXMEGA.elf -Wl,-Map=basic-passwdcheck-CWLITEXMEGA.map,--cref -lm
.
Creating load file for Flash: basic-passwdcheck-CWLITEXMEGA.hex
avr-objcopy -O ihex -R .eeprom -R .fuse -R .lock -R .signature basic-passwdcheck-CWLITEXMEGA.elf basic-passwdcheck-CWLITEXMEGA.hex
.
Creating load file for EEPROM: basic-passwdcheck-CWLITEXMEGA.eep
avr-objcopy -j .eeprom --set-section-flags=.eeprom="alloc,load" \
--change-section-lma .eeprom=0 --no-change-warnings -O ihex basic-passwdcheck-CWLITEXMEGA.elf basic-passwdcheck-CWLITEXMEGA.eep || exit 0
.
Creating Extended Listing: basic-passwdcheck-CWLITEXMEGA.lss
avr-objdump -h -S -z basic-passwdcheck-CWLITEXMEGA.elf > basic-passwdcheck-CWLITEXMEGA.lss
.
Creating Symbol Table: basic-passwdcheck-CWLITEXMEGA.sym
avr-nm -n basic-passwdcheck-CWLITEXMEGA.elf > basic-passwdcheck-CWLITEXMEGA.sym
Size after:
text data bss dec hex filename
2406 304 260 2970 b9a basic-passwdcheck-CWLITEXMEGA.elf
+--------------------------------------------------------
+ Built for platform CW-Lite XMEGA
+--------------------------------------------------------
| MIT | VM_Files/Mikrocontroller_1_Prepare.ipynb | stefanwitossek/securec_ws1920 |
Setup Flash compiled Code to Target | %run "Helper_Scripts/Setup_Generic.ipynb"
fw_path = '../hardware/victims/firmware/Mikrocontroller_1/basic-passwdcheck-{}.hex'.format(PLATFORM)
cw.program_target(scope, prog, fw_path) | XMEGA Programming flash...
XMEGA Reading flash...
Verified flash OK, 2709 bytes
| MIT | VM_Files/Mikrocontroller_1_Prepare.ipynb | stefanwitossek/securec_ws1920 |
Disconnect Scope and Target | scope.dis()
target.dis() | _____no_output_____ | MIT | VM_Files/Mikrocontroller_1_Prepare.ipynb | stefanwitossek/securec_ws1920 |
Annotation Converter> Converter to covert annotations into different formats. | # export
def convert(input_adapter: AnnotationAdapter, output_adapter: AnnotationAdapter):
"""
Convert input annotations to output annotations.
`input_adapter`: the input annotation adapter
`output_adapter`: the output annotation adapter
"""
categories = input_adapter.read_categories()
annotations = input_adapter.read_annotations(SubsetType.TRAINVAL)
output_adapter.write_categories(categories)
output_adapter.write_annotations(annotations, SubsetType.TRAINVAL) | _____no_output_____ | Apache-2.0 | annotation_converter.ipynb | AI-Force/aiforce |
Helper Methods | # export
def configure_logging(logging_level=logging.INFO):
"""
Configures logging for the system.
:param logging_level: The logging level to use.
"""
logging.basicConfig(level=logging_level) | _____no_output_____ | Apache-2.0 | annotation_converter.ipynb | AI-Force/aiforce |
Run from command line To run the annotation converter from command line, use the following command:`python -m mlcore.annotation_converter [parameters]` The following parameters are supported:- `-i`, `--input_adapter`: The annotation adapter to the annotations to convert from (e.g.: *VIAAnnotationAdapter*)- `-o`, `--output_adapter`: The annotation adapter to the annotations to convert to (e.g.: *MultiCategoryAnnotationAdapter*) | # export
if __name__ == '__main__' and '__file__' in globals():
# for direct shell execution
configure_logging()
# read annotation adapters to use
adapters = list_subclasses(annotation_package, AnnotationAdapter)
parser = argparse.ArgumentParser()
parser.add_argument("-i",
"--input_adapter",
help="The annotation adapter to read the annotations.",
type=str,
choices=adapters.keys())
parser.add_argument("-o",
"--output_adapter",
help="The annotation adapter to write the annotations.",
type=str,
choices=adapters.keys())
argv = sys.argv
args, argv = parse_known_args_with_help(parser, argv)
input_adapter_class = adapters[args.input_adapter]
output_adapter_class = adapters[args.output_adapter]
# parse the input arguments
input_parser = getattr(input_adapter_class, 'argparse')(prefix='input')
input_args, argv = parse_known_args_with_help(input_parser, argv)
# parse the output arguments
output_parser = getattr(output_adapter_class, 'argparse')(prefix='output')
output_args, argv = parse_known_args_with_help(output_parser, argv)
convert(input_adapter_class(**vars(input_args)), output_adapter_class(**vars(output_args))) | _____no_output_____ | Apache-2.0 | annotation_converter.ipynb | AI-Force/aiforce |
Example: Image Object Detection to Multi Category Image Classification To convert image object detection annotations to multi category image classifications, run the following command: `python -m mlcore.annotation_converter --input_adapter VIAAnnotationAdapter --input_path data/image_object_detection/my_collection --output_adapter MultiCategoryAnnotationAdapter --output_path data/image_classification/my_collection` | # hide
# for generating scripts from notebook directly
from nbdev.export import notebook2script
notebook2script() | Converted annotation-core.ipynb.
Converted annotation-folder_category_adapter.ipynb.
Converted annotation-multi_category_adapter.ipynb.
Converted annotation-via_adapter.ipynb.
Converted annotation-yolo_adapter.ipynb.
Converted annotation_converter.ipynb.
Converted annotation_viewer.ipynb.
Converted category_tools.ipynb.
Converted core.ipynb.
Converted dataset-core.ipynb.
Converted dataset-image_classification.ipynb.
Converted dataset-image_object_detection.ipynb.
Converted dataset-image_segmentation.ipynb.
Converted dataset-type.ipynb.
Converted dataset_generator.ipynb.
Converted evaluation-core.ipynb.
Converted geometry.ipynb.
Converted image-color_palette.ipynb.
Converted image-inference.ipynb.
Converted image-opencv_tools.ipynb.
Converted image-pillow_tools.ipynb.
Converted image-tools.ipynb.
Converted index.ipynb.
Converted io-core.ipynb.
Converted tensorflow-tflite_converter.ipynb.
Converted tensorflow-tflite_metadata.ipynb.
Converted tensorflow-tfrecord_builder.ipynb.
Converted tools-check_double_images.ipynb.
Converted tools-downloader.ipynb.
Converted tools-image_size_calculator.ipynb.
| Apache-2.0 | annotation_converter.ipynb | AI-Force/aiforce |
Subsets and Splits
No saved queries yet
Save your SQL queries to embed, download, and access them later. Queries will appear here once saved.