| TEZ-1624 |
Flaky tests in TestContainerReuse due to race condition in DelayedContainerManager thread |
Major |
. |
Rajesh Balamohan |
Rajesh Balamohan |
| TEZ-1613 |
Decrease running time for TestAMRecovery |
Major |
. |
Jeff Zhang |
Jeff Zhang |
| TEZ-1612 |
ShuffleVertexManager's EdgeManager should not hard code source num tasks |
Major |
. |
Daniel Dai |
Bikas Saha |
| TEZ-1611 |
Change DataSource/Sink to be able to supply URIs for credentials |
Major |
. |
Bikas Saha |
Bikas Saha |
| TEZ-1609 |
Add hostname to logIdentifiers of fetchers for easy debugging |
Major |
. |
Rajesh Balamohan |
Rajesh Balamohan |
| TEZ-1599 |
TezClient.preWarm() is not enabled |
Major |
. |
Bikas Saha |
Bikas Saha |
| TEZ-1598 |
DAGClientTimelineImpl uses ReflectiveOperationException (which has JDK 1.7 dependency) |
Major |
. |
Rajesh Balamohan |
Rajesh Balamohan |
| TEZ-1597 |
ImmediateStartVertexManager should handle corner case of vertex having zero tasks |
Major |
. |
Rajesh Balamohan |
Rajesh Balamohan |
| TEZ-1592 |
Vertex should wait for all initializers to finish before moving to INITED state |
Blocker |
. |
Siddharth Seth |
Siddharth Seth |
| TEZ-1587 |
Some tez-examples fail in local mode |
Major |
. |
Jeff Zhang |
Prakash Ramachandran |
| TEZ-1585 |
Memory leak in tez session mode |
Major |
. |
Rajesh Balamohan |
Rajesh Balamohan |
| TEZ-1581 |
GroupByOrderByMRRTest no longer functional |
Major |
. |
Hitesh Shah |
Hitesh Shah |
| TEZ-1580 |
Change TestOrderedWordCount to optionally use MR configs |
Major |
. |
Hitesh Shah |
Hitesh Shah |
| TEZ-1575 |
MRRSleepJob does not pick MR settings for container size and java opts |
Major |
. |
Hitesh Shah |
Hitesh Shah |
| TEZ-1574 |
Support additional formats for the tez deployed archive |
Major |
. |
Siddharth Seth |
Siddharth Seth |
| TEZ-1571 |
Add create method for DataSinkDescriptor |
Blocker |
. |
Jeff Zhang |
Jeff Zhang |
| TEZ-1563 |
TezClient.submitDAGSession alters DAG local resources regardless of DAG submission |
Major |
. |
Josh Elser |
Bikas Saha |
| TEZ-1549 |
[Umbrella] Unit tests fail on Windows |
Major |
. |
Hitesh Shah |
Prakash Ramachandran |
| TEZ-1548 |
ShuffleVertexManagerConfigBuilder.setSlowStartMinSrcCompletionFraction setting wrong value |
Major |
. |
Rajesh Balamohan |
Rajesh Balamohan |
| TEZ-1544 |
Link to release artifacts for 0.5.0 does not point to a specific link for 0.5.0 |
Trivial |
. |
Hitesh Shah |
Hitesh Shah |
| TEZ-1543 |
Shuffle Errors on heavy load (causing task retries) |
Major |
. |
Rajesh Balamohan |
Rajesh Balamohan |
| TEZ-1536 |
Fix spelling typo "configurartion" in TezClientUtils |
Trivial |
. |
Hitesh Shah |
Hitesh Shah |
| TEZ-1527 |
Improvement on waitForCompletion API |
Major |
. |
Jeff Zhang |
Jeff Zhang |
| TEZ-1524 |
getDAGStatus seems to fork out the entire JVM on non-secure clusters |
Major |
. |
Gopal V |
Gopal V |
| TEZ-1519 |
TezTaskRunner should not initialize TezConfiguration in TezChild |
Blocker |
. |
Hitesh Shah |
Prakash Ramachandran |
| TEZ-1515 |
DAGAppMaster : Thread contentions due to org.apache.tez.common.counters.ResourceBundles |
Major |
. |
Rajesh Balamohan |
Rajesh Balamohan |
| TEZ-1495 |
ATS integration for TezClient |
Major |
. |
Prakash Ramachandran |
Prakash Ramachandran |
| TEZ-1494 |
DAG hangs waiting for ShuffleManager.getNextInput() |
Major |
. |
Rajesh Balamohan |
Rajesh Balamohan |
| TEZ-1488 |
Rename HashComparator to ProxyComparator and implement in TezBytesComparator |
Major |
. |
Gopal V |
Gopal V |
| TEZ-1447 |
Provide a mechanism for InputInitializers to know about interesting Vertex state changes |
Blocker |
. |
Gunther Hagleitner |
Siddharth Seth |
| TEZ-1433 |
Invalid credentials can be used when a DAG is submitted to a session which has timed out |
Blocker |
. |
Siddharth Seth |
Bikas Saha |
| TEZ-1362 |
Remove DAG_COMPLETED in DAGEventType |
Major |
. |
Jeff Zhang |
Jeff Zhang |
| TEZ-1310 |
Update website documentation framework |
Major |
. |
Hitesh Shah |
Jonathan Eagles |
| TEZ-978 |
Enhance auto parallelism tuning for queries having empty outputs or data skewness |
Major |
. |
Rajesh Balamohan |
Rajesh Balamohan |


Before Change
elif isinstance(lang, spacy.language.Language):
// just want to make sure that doc and lang share the same vocabulary
if doc.vocab is not lang.vocab:
raise ValueError(
"`spacy.vocab.Vocab` used to process document ("{}") "
"must be the same as that used by the `lang` pipeline ("{}")".format(
doc.vocab, lang.vocab
)
)
elif callable(lang) is False:
// there"s nothing to be done with a callable lang, since we already have
// the doc, and checking the text lang is an unnecessary performance hit
raise TypeError(
After Change
elif callable(lang) is False:
// there"s nothing to be done with a callable lang, since we already have
// the doc, and checking the text lang is an unnecessary performance hit
raise TypeError(
errors.type_invalid_msg(
"lang", type(lang), Union[str, Callable[[str], str], Language]
)
)
return doc


==== Human Angle ====
During a physical penetration test, some of the most obvious ways would be to social-engineer your way into the facility and gain access. This requires significant knowledge of how the organization performs business, and everything you learned from the intelligence gathering phase.


This is widely found (see Gmail below) UI Pattern which can act as a work horse Pattern in our set of solutions
The Master - Detail could amended to behave as a Wizard whereby the active row is the active Step of the Wizard.
The Master - Detail could amended to behave as a Wizard whereby the active row is the active Step of the Wizard.
Without adaption it is inappropriate for use on smaller screens. Modality is useful Pattern to help here.
<EMAIL_ADDRESS>This implementation of 2 layer Master > Detail is creating a layer while leaving the main navigation in place. This illustrates that Master > Detail inside a single 'Mode'.
The example below shows the Master / Detail with a Material style treatment. The 'John Doe' detail view isn't strictly a Modal screen - there is no Cancel or Save buttons


with AssemblyScript
AssemblyScript is a project that compiles TypeScript to WebAssembly.
The basic build command:
asc main.ts -o main.wasm
// basically JS with some types: export function add(a: u32, b: u32): u32 { return a + b; }
These examples aren't trying to prevent leaks, so when you actually go do something, remember to free memory.
More about how wasm-ffi handles memory in the readme.
.wasm
modules
To load a
.wasm
module, you need to fetch it from the server and then load it with
WebAssembly.instantiateStreaming
. You can do that yourself or
wasm-ffi
will do it with
.fetch(url)
.
For AssemblyScript module's you'll need to set the dialect
option so wasm-ffi will know how to handle strings and arrays.
import { Wrapper } from 'wasm-ffi'; // WebAssembly function you want to wrap will go here const library = new Wrapper({ // do_thing: [return_type, [arg_type_1. arg_type_2]] }, { // need to set option for assemblyscript dialect: 'assemblyscript', ]}); library.fetch('main.wasm').then(() => { // library is now loaded and you can call your wrapped WebAssembly functions: // library.do_thing() });
.wasm
Requirements
wasm-ffi
can read data from WebAssembly memory without any changes to your module. You can
read strings, read struct fields, modify existing struct fields, etc.
If your JavaScript needs to allocate any memory (passing strings,
making structs) you need to expose allocate
&
deallocate
functions.
import 'allocator/buddy'; export function allocate(size: usize): usize { return allocate_memory(size); } export function deallocate(ptr: usize): void { free_memory(ptr); }
The format for wrapping functions is:
functionName: [returnType, [...argTypes]]
Ex: the say
function takes a string pointer and returns a string pointer:
['string', ['string']]
// wrap our exported C function `say`: const library = new Wrapper({ say: ['string', ['string']], }); library.fetch('main.wasm').then(() => { // call `say` on btn click: $('#say-hello').addEventListener('click', () => { alert(library.say('Hello')); }); });
wasm-ffi
supports ArrayBuffers & TypedArrays as an argument type. It will write the arrays
to memory and pass the pointer to your
.wasm
function.
By default the array will be freed after the function returns.
const library = new Wrapper({ get_sum: ['number', ['array']], }); // ... $('#get-sum').addEventListener('click', () => { const arr = new U32Array([1, 1, 2, 3, 5, 8, 13, 21]); const sum = library.get_sum(arr); $('#sum-log').innerText = `Sum of ${arr} is: ${sum}`; });
A
Pointer
object encapsulates a reference to wasm memory.
.ref()
: get memory address.deref()
: get data.set(value)
: set pointers value.free()
: free from wasm memory
Create a new pointer with
new Pointer(type, value)
.
import { types, Pointer } from 'wasm-ffi'; const library = new Wrapper({ get_pointer: [types.pointer('u32')], pass_pointer: ['number', [types.pointer('u32')]], }); // ... $('#get-pointer').addEventListener('click', () => { const ptr = library.get_pointer(); $('#pointer-log').innerText = `Value ${ptr.deref()} is located @ ${ptr.ref()}`; }); $('#pass-pointer').addEventListener('click', () => { const ptr = new ffi.Pointer('u32', 365); const value = library.pass_pointer(ptr); $('#pointer-log').innerText = `Wasm read ${value} from the pointer you sent`; });
wasm-ffi
wraps struct pointers into objects that let you access fields.
To use a struct you first have to define a struct type. The order of the properties should be the same as
your AssemblyScript definition. Use this new Struct
type in your wrapped function signatures.
You can get the memory address of a struct with
.ref()
and you can free it from memory with
.free()
import { Struct } from 'wasm-ffi'; // define a new struct type: Person const Person = new Struct({ name: 'string', age: 'u8', favorite_number: 'u32', }); const library = new Wrapper({ get_person: [Person], person_facts: ['string', [Person]], }); // ... $('#get-person').addEventListener('click', () => { const p = library.get_person(); const about = `${p.name} is ${p.age}. His favorite number is ${p.favorite_number}.`; $('#person-log').innerText = about; }); $('#modify-person').addEventListener('click', () => { // modify the properties of a struct: const p = library.get_person(); p.age = 255; p.favorite_number = 100; $('#person-log').innerText = `New age: ${p.age}\n`; $('#person-log').innerText += `New favorite: ${p.favorite_number}\n`; $('#person-log').innerText += library.person_facts(p); });
A struct definition (like above) is also a constructor you can use to make new structs from JS. Any struct made in JS will get written to memory the first time it is used in a WebAssembly function.
const Person = new Struct({ name: 'string', age: 'u8', favorite_number: 'u32', }); // ... $('#make-person').addEventListener('click', () => { const name = $('#name').value; const age = parseInt($('#age').value); const num = parseInt($('#num').value); const person = new Person({ name: name, age: age, favorite_number: num, }); $('#make-log').innerText = library.person_facts(person); });
To call a JS function from AssemblyScript you need to
import the JS function into your wasm module. These functions
need to be in the env
namespace.
// `barrel_roll` will call the `rotate` function below const library = new Wrapper({ barrel_roll: [], // no arguments }); // this needs to be done before `library.fetch('main.wasm')` library.imports({ env: { rotate: function() { $('body').classList.toggle('rotate'); }, }, }); // ... $('#barrel-roll').addEventListener('click', () => { library.barrel_roll(); });
You can also wrap imported functions using the same notation as with a
Wrapper
. The last argument is the function to wrap. This will convert the inputs and outputs
of the function to the right types.
// `multiply_input` will call `get_input_value` below: const library = new Wrapper({ multiply_input: ['number', ['string']], }); // change imports to a callback to expose the wrap fn // (remember to return an object here with the extra parenthesis: `({ ... })`) library.imports(wrap => ({ env: { // ... // `get_input_value` takes a string and returns a number get_input_value: wrap(['number', ['string']], (selector) => { return parseInt($(selector).value); }), }, })); // ... $('#multiply').addEventListener('click', () => { // gets the .value and multiplies it by 2 const number = library.multiply_input('body #number'); $('#multiply-log').innerText = `Result: ${number}`; });


Hello! This is an experimental blockchain platform built by Sam Chun. This blockchain is secured with a Proof of Work mechanism (an alternate Proof of Stake consensus system is in progress), and it closely models the structure and architecture of Satoshi Nakomoto's original paper. The blocks currently store transaction data between addresses and they are linked together with SHA-1 hashes.
The REST API was built from Flask in Python and handles all requests to the blockchain, wallets, transactions, nodes, and mining. All endpoints are listed on the project's Github page.
In order to send and receive Weepo coins, you first need to create your RSA-secured blockchain wallet. The wallet's public key is your address, and the private key creates the signature that verifies transactions. Do not share your private key with anyone. There is a fee of one Weepo coin per transaction.
In order to mine blocks and receive rewards, you'll need to connect to the Weepo Blockchain port (default is <IP_ADDRESS>:5000). Then head to 'Settings' and add the URL of at least one node that is already on the network; this will act as your "invite" to the main chain.


Haythem Jlassi
Home page
Github
Resume
Assignments
Contact
This website was created for my CS290 class. I used Dropbox and Droppages to host the website.


Welcome to my GIS web portfolio! I am a GIS professional at the State of Wisconsin Elections Commission and Master's Graduate from UW Madison. Have a look around at some of my geographic creations and other projects that I have been involved in. Please reach out with any questions!


Collymore says Liverpool’s Oxlade-Chamberlain can be England’s new Gascoigne
by Tom ProcterStan Collymore reckons Liverpool midfielder Alex Oxlade-Chamberlain is the closest thing England have to a modern-day Paul Gascoigne.
The ex-Red made the observation in a column for The Mirror, before the Three Lions beat Kosovo 4-0 to win their Euro 2020 qualifying group on Sunday.
Oxlade-Chamberlain started in Pristina and received the highest rating of any player from BBC Sport after the game.
He also started against Montenegro days earlier, and Collymore reckons he has the potential to provide the wow factor for his country as Gascoigne so often did in the 90s.
He said: “As for Montenegro, they were disappointing and the game left me feeling that we still desperately need a player who can run with the ball from the halfway line to the edge of the opponents’ box next summer. A Paul Gascoigne-type figure.
“The one man who can do it is Alex Oxlade-Chamberlain.
“Now, I’m not comparing him to Gazza, but what I am saying is that he gave us a taster last week of his ability to run with the ball and commit midfielders and defenders – and that’s not something any England player has done well for a long time.
“Maddison and Mount do it from time to time, but not in the same way as the Ox, who can run past players at pace.”
TBR’s view – Bold comments
Collymore says he isn’t comparing, but his comments are unlikely to go down well.
Gascoigne was one of the most naturally gifted players of his generation, and so the bar is very high.
Oxlade-Chamberlain – who earns £120,000-a-week at Anfield (Spotrac) – is a fine player and he might share traits with Gascoigne, but hyping him up as the potential second coming is probably unwise.
Have something to tell us about this article?
Let us know


Fees Settings
New
Back
STATE BOARD
ICSE BOARD
CBSE BOARD
SCIENCE
×
Add New Fee Structure
Product Name
Type
Board
STATE
ICSE
CBSE
Fees
Discount
GST
Start Date
End Date
City Name
{{city.cityname}}
{{headBoard}}
{{feeinfo.productname}}th
Course fees
Discount
Start Date
End Date
Save
No Data Found


|
MXQuery 0.6.0 API Documentation - Copyright 2006-2009 ETH Zurich | ||||||||
| PREV CLASS NEXT CLASS | FRAMES NO FRAMES | ||||||||
| SUMMARY: NESTED | FIELD | CONSTR | METHOD | DETAIL: FIELD | CONSTR | METHOD |
java.lang.Object ch.ethz.mxquery.contextConfig.CompilerOptions
public class CompilerOptions
| Constructor Summary | |
|---|---|
CompilerOptions()
|
| Method Summary | |
|---|---|
boolean |
isContinuousXQ()
Check if Continuous XQuery expressions (infinite XDM sequences) should be used |
boolean |
isFulltext()
Check if XQuery/XPath Full Text expressions should be considered |
boolean |
isParallelExecution()
Check if parallel execution should be used (experimental) |
boolean |
isSchemaAwareness()
Check if XML Schema related expressions should be use |
boolean |
isScripting()
Check if XQuery Scripting expressions should be considered |
boolean |
isUpdate()
Check if XQuery Update Facility expressions should be considered |
boolean |
isXquery11()
Check if XQuery 1.1 expressions should be considered |
void |
setContinuousXQ(boolean continuousxq)
Determine if Continuous XQuery expressions (infinite XDM) should be used |
void |
setFulltext(boolean fulltext)
Determine if XQuery/XPath Full Text expressions should be used |
void |
setParallelExecution(boolean parallelExecution)
Determine if parallel execution should be used (experimental) |
void |
setSchemaAwareness(boolean schemaAwareness)
Determine if XML Schema related expressions should be used |
void |
setScripting(boolean scripting)
Determine if XQuery Scripting expressions should be used |
void |
setUpdate(boolean update)
Determine if XQuery Update Facility expressions should be used |
void |
setXquery11(boolean xquery11)
Determine if XQuery 1.1 expressions should be used |
| Methods inherited from class java.lang.Object |
|---|
equals, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait |
| Constructor Detail |
|---|
public CompilerOptions()
| Method Detail |
|---|
public boolean isXquery11()
public void setXquery11(boolean xquery11)
xquery11
- true: use XQuery 1.1 expressions, false: don't usepublic boolean isContinuousXQ()
public void setContinuousXQ(boolean continuousxq)
continuousxq
- true: use Continuous XQuery expressions, false: don't usepublic boolean isScripting()
public void setScripting(boolean scripting)
scripting
- true: use XQuery scripting expressions, false: don't usepublic boolean isFulltext()
public void setFulltext(boolean fulltext)
fulltext
- true: use XQuery/XPath Full Text expressions, false don'tpublic boolean isUpdate()
public void setUpdate(boolean update)
update
- true: use XQuery Update Facility expressions, false don'tpublic boolean isSchemaAwareness()
public void setSchemaAwareness(boolean schemaAwareness)
schemaAwareness
- true: use XML Schema related expressions, false don'tpublic boolean isParallelExecution()
public void setParallelExecution(boolean parallelExecution)
parallelExecution
- true: use parallel forseq/groupby, false don't
|
MXQuery 0.6.0 API Documentation - Copyright 2006-2009 ETH Zurich | ||||||||
| PREV CLASS NEXT CLASS | FRAMES NO FRAMES | ||||||||
| SUMMARY: NESTED | FIELD | CONSTR | METHOD | DETAIL: FIELD | CONSTR | METHOD |


The options for review schema parts that have options
| Name | Description |
|---|---|
| peer_assignment_id | The assignment that this option is in |
| peer_assignment_review_schema_part_id | The schema part that this option is for |
| peer_assignment_review_schema_part_option_id | This option's id within the part |
| peer_assignment_review_schema_part_option_text | The text of this option |
| peer_assignment_review_schema_part_option_score | The score of this option. Note that this is nullable because not all options make scores. |
CREATE TABLE peer_assignment_review_schema_part_options ( peer_assignment_id VARCHAR(50) ,peer_assignment_review_schema_part_id VARCHAR(50) ,peer_assignment_review_schema_part_option_id VARCHAR(50) ,peer_assignment_review_schema_part_option_text VARCHAR(65535) ,peer_assignment_review_schema_part_option_score FLOAT8 ,PRIMARY KEY (peer_assignment_id, peer_assignment_review_schema_part_id, peer_assignment_review_schema_part_option_id) ,FOREIGN KEY (peer_assignment_id, peer_assignment_review_schema_part_id) REFERENCES peer_assignment_review_schema_parts(peer_assignment_id, peer_assignment_review_schema_part_id) ,FOREIGN KEY (peer_assignment_id) REFERENCES peer_assignments(peer_assignment_id) );


“I am a slow walker, but I never walk back.”
-Abraham Lincoln
Learn more about the trials & tribulations of Abraham Lincoln on his wikipedia page


Validation Layers
Since all the fields conform to the Field class, validation layers tied directly to the Fields has never been easier!
Lets define 3 fields, an EntryField, an AreaField, and a PickerField
let entryField = EntryField()
let areaField = AreaField()
let pickerField = PickerField()
Lets also define a CaseIterable enum:
extension CaseIterable where AllCases.Element: Equatable {
static func make(index: Int) -> Self? { //get the key from the case index
let a = Self.allCases
if (index > a.count - 1) { return nil } //out of range
return a[a.index(a.startIndex, offsetBy: index)]
}
func index() -> Int { //get the index from the case
let a = Self.allCases
return a.distance(from: a.startIndex, to: a.firstIndex(of: self)!)
}
}
enum FieldKeys : String, CaseIterable {
case entry
case area
case picker
}
With our CaseIterable enum we can use the validation keys as tags for the fields!
entryField.tag = FieldKeys.entry.index()
areaField.tag = FieldKeys.area.index()
pickerField.tag = FieldKeys.picker.index()
Lets say we need to validate a generic string (with the regex set in our core data model) before commiting changes to our model using an extension on NSManagedObject.
extension NSManagedObject {
func validateString(view: Field, key: String){
var value = view.text as AnyObject?
do {
try self.validateValue(&(value), forKey: key)
} catch {
view.setError(withText: "please try again")
print(error)
return
}
self.setValue(value, forKey: key)
}
}
Now on any of the fields’ didEndEditing delegate methods we only need to 2 lines to validate our entry.
//EntryFieldDelegates
func entryFieldDidEndEditing(_ view: EntryField){
//the key reconstructed from our enum used for the field tags
gaurd let key = FieldKeys.make(index: view.tag) else {return}
ourNSManagedObject.validateString(view,key.rawValue)
}
//AreaFieldDelegates
func areaFieldDidEndEditing(_ view: AreaField){
//the key reconstructed from our enum used for the field tags
gaurd let key = FieldKeys.make(index: view.tag) else {return}
ourNSManagedObject.validateString(view,key.rawValue)
}
//PickerFieldDelegates
func pickerFieldDidEndEditing(_ view: PickerField){
//the key reconstructed from our enum used for the field tags
gaurd let key = FieldKeys.make(index: view.tag) else {return}
ourNSManagedObject.validateString(view,key.rawValue)
}
We now have a validation layer capable of both data model validation and UI feedback!


Delicious
THE BEST FOOD BLOG ON THE WEB.
THE BEST FOOD BLOG ON THE WEB.
POSTED ON 15 DEC 2013 / DESSERTS
For the fig-swirl: Melt butter over medium heat in a saucepan.Add brown sugar and stir to dissolve. Halve of the figs and toss in the saucepan with water and lemon juice.Cook over medium heat, stirring frequently, until you have a chunky-jammy mixture.Add salt with one or two stirs, set aside and let cool completely.
Ice cream: In a small pot over medium heat, combine milk, and granulated sugar until sugar is completely dissolved and the milk is just barely lukewarm.Whisk in the egg yolks. Set mixture in the fridge and wait until the fig mixture is cooled
Using an ice cream machine, pour liquids into the frozen basin and process according to manufacturer instructions, i.e., let spin and thicken for 20 minutes before adding mascarpone, fig jam mixture, and the nuts.Continue to process for +/- 10 minutes.Pour semi-frozen mixture into a pyrex dish or glass tupperware.Freeze for at least two hours before serving.


Hot Dog, Fries and a Soda
Burger, Shake and a Smile
Sugar, Spice and all things nice
Baby Back Ribs
A really really long option made to illustrate an issue with the live search in an inline form


|------------------| | Image Data | | Generator | | (ColorBars) | |__________________| | V |-----------------| | SGDMA IP Core |<-------------+ |_________________| | | | V | |-----------------| | | PCIe IP Core | | |_________________| |----------------| | | Driver | V |________________| |----------------| ^ | Image Buffer |<--+ | |________________| | |----------------| | |_____| Application | V | (this file) | |----------------| |________________| | OpenGL Window | |________________|
The image is displayed using OpenGL calls. The display rate is therefore also dependent on the OpenGL library and graphics subsystem hardware. Displaying an image is a quick way to illustrate that data has been moved. It would not be practical to display 1MB to the screen in a text dump, or save it to a file. An image provides a quick, visual way to observe a large transfer of data, and it can run continuously.
The image data is 1MB in size. Each DMA Read request is 1MB in size. After the hardware has transferred the pixel data, the API call returns and the software displays the image. This loop is repeated over and over. The data rate (frame rate) is displayed in the window title bar. The frame rate is roughly the throughput rate in MB/sec. (each frame = 1 MB). Frame rate is governed by the video refresh rate. Most video systems will not draw frames into video memory faster than the frame rate (waste of operations).
Running:
The main structure of this application is based on OpenGL and glut (GL Utilities Libraries). Printf's go to a console. The graphics window needs to have focus to accept commands.


Toggle navigation
Home
Structure
Exhibition 2012
Comparison Tool
Bibliography & Links
Credits
Exhibition 2012
Click on the book images below to explore a digitized version of each text.
MS Lat 133
MS Lat 159
MS Lat 250
MS Lat 251
MS Lat 253
MS Rich 34
MS Rich 42
MS Rich 7
MS Typ 1000
MS Typ 999
MS Lat 17
MS Lat 160
MS Rich 6
MS Rich 9
MS Rich 5
MS Lat 249


Google App Engine Java applications aren't allowed to use some APIs (e.g. Thread's class constructor) and declare native methods.


I frequently give talks at various Tech conferences and meetups. I’ve given talks about Postgres/Databases, Python/Django, and cultural talks around effective engineering and product teams. Currently I’m interested on speaking related to Postgres, product management, and marketing for developer focused companies. If you’re interested in having me speak at a meetup or upcoming conference please reach out to me at craig.kerstiens at gmail.com.
Upcoming Talks
2013-04-02 – Great Wide Open
2013-04-04 – Ancient City Ruby
2013-04-15 – PyCon
Past Talks
2014-02-23 – PyTennessee – Going beyond limits of Django ORM with Postgres
2014-02-01 – FOSDEM – Postgres Performance for Humans
2013-11-13 – Dreamforce
2013-10-29 – PgConf EU
2013-09-17 – Postgres Open
2013-07-03 – EuroPython
2013-05-15 – DjangoCon EU
2013-04-04 – Mountain West Ruby Conf – Postgres Demystified
2013-03-18 – PyCon US – Going beyond the Django ORM limitations with Postgres
2013-02-02 – Fosdem – Postgres Demystified
2013-01-31 – Monkigras – Coffee as Collaboration
2012-11-23 – All Your Base Conf – Postgres Demystified Video
2012-11-15 – PyCon Argentina – Django Apps to Services
2012-11-13 – PgDay Argentina – Postgres Demystified
2012-07-16 – OSCON – Django Apps to Services Video
2012-06-28 – CloudEast – 12 Factor App
2012-06-06 – DjangoCon EU – How Heroku Uses Heroku to Build Heroku
2012-04-15 – DjangoCong – Django Apps to Services


AR
Refresh your browser if camera or AR objects are not loaded.
champion
Click here to start. Point the camera preview on the same target image in your world.


1. Ad mime type to initializer/mime_type.rb file
EX. Mime::Type.register 'application/xls', :xls
for xls file
2. Add following code to corresponding controller respectively for csv and xls format.
format.csv do
# Don't Try to Put Headers into single line, it wont work
# header info. Use your custom filename
headers['Content-Disposition'] = "attachment; filename=\"campaigns_list_brand_#{Time.now.strftime('%Y%m%d_%H_%M_%S')}.csv\""
#content type declaretion. It is only difference btw xls file
headers['Content-Type'] ||= 'text/csv'
# rendered view which has extention .csv.rb
like for this example export_brand_campaigns.csv.rb
render 'campaigns/export_brand_campaigns'
end
format.xls do
# all thing like csv format
headers['Content-Disposition'] = "attachment; filename=\"campaigns_list_influencer_#{Time.now.strftime('%Y%m%d_%H_%M_%S')}.xls\""
render 'campaigns/export_influencer_campaigns'
end
3. view code
<%- headers = ['Campaign Name', 'Post Likes', 'Reach', 'Comments', 'Shares', 'Campaign Starts', 'Campaign Ends'] -%>
<%= CSV.generate_line headers %>
<% @campaigns.each do |campaign| %>
<%= CSV.generate_line([campaign.name, campaign.number_of_likes, campaign.number_of_post_reach, campaign.number_of_comments, campaign.number_of_shares, campaign.start_date, campaign.end_date.present? ? campaign.end_date : 'NA']).html_safe.strip %>
<% end %>
Actually CSV.generate_line
which generage line with given data. .html_safe and .strip
are corresponding for html safe and remove white space.


Cabbie Azhar Ali Mehmood torched the Lowe family home in 2000 after subjecting Lucy to three years of abuse.
Her mum Eileen, 49, and sister Sarah, 17, also perished.
Child groomer Mehmood, 45, was convicted of the triple murder but never charged with sex crimes despite Lucy conceiving his daughter Tasnim two years earlier.
Lucy was pregnant again when she died at the age of 16.
The killer is up for parole this month but won’t be forced to sign the sex offenders register if released.
And Tasnim, now 20, has been told by senior officers there will be no fresh probe into his sex offences.
She said: “I think it’s very important that my dad should be prosecuted for all his crimes. Police knew about the sex crimes but didn’t do anything about it.
“He’s only been charged with murder because they wanted to convict him of the most serious crime.
“I asked the police, ‘Now that we know everything we know, is this going to be changing at all?’ And they said no.
“We need to acknowledge the problem and they’re not doing that.
"He should be on the sex offenders list for the safety of others. I’m living proof.
“It’s difficult to come to terms with the fact abuse is why I exist. I was born out of the fact my dad raped my mum.”
The Sunday Mirror can reveal support worker Tasnim met Supt Paul Moxley, from West Mercia Police, to find out why her dad won’t be charged with abuse.
Supt Moxley said had Lucy died in similar circumstances today, Mehmood would likely be tried for sex crimes.
But in comments likely to provoke fury, he claimed the force was reluctant to launch a fresh probe for fear of being criticised for not bringing the crimes to light earlier.
He said: “If I put myself into the words of a defence barrister, I’d say ‘You knew this 19 years ago. Why didn’t it come to the fore then?’
"We could be accused of abuse of process. I think it’s definitely different now, from 20 years ago.
"We would absolutely be looking and saying, ‘How can your mum have been 14 and pregnant? What’s going on there?’
“If child exploitation or sex offences had occurred, that would all form part of the evidence bundle going to the Crown Prosecution Service.”
Tasnim’s exchange with the officer features in a BBC documentary she has spent the past year making about the circumstances which led to the deaths of her family.
She survived the fire after Mehmood placed her under an apple tree before torching the house.
The only other survivor was her grandad George, 74, who brought her up.
Mehmood was jailed for life with a minimum term of 18 years for the killings and the attempted murder of George – Lucy’s dad.
The Sunday Mirror told last year how up to 1,000 schoolgirls could have been abused in Telford over 40 years.
We also revealed another girl told the murder inquiry how she was also raped by Mehmood and claimed he was among a group of men targeting schoolgirls in the town.
But cops took a decade to launch a dedicated child sexual exploitation probe – in which time hundreds more girls were abused and two others died.

Her friend Vicky Round died at 20 in a drug-related incident in 2009 after sex gangs got her hooked on crack cocaine at 12 and heroin at 14.
And now, the full extent of Lucy’s hellish ordeal at the hands of Mehmood and other child groomers can be revealed for the first time.
She was first preyed on by the killer when she was 13.
And heartbreaking diaries and letters salvaged from the fire reveal he wasn’t the only man who violated her.
Lucy wrote that she and other girls were taken to a secluded local beauty spot, The Wrekin hill, and abused by a group of men.
Tasnim said: “She performed sex acts on older men. It makes you think, who were they? What were they doing? There are parts that make you really upset.”
The diaries, returned to Tasnim by officers just months ago, also show how Mehmood pressured Lucy not to tell authorities about the fact they had sex while she was under age.
Tasnim said: “He asked Lucy if she had gone to the police. She said no. If he had to ring her to say, ‘Have you gone to the police about me?’ that clearly indicates the relationship was illegal and it wasn’t right.”
In a heartbreaking letter to Tasnim, written days after she gave birth, Lucy reveals her fears that her daughter will suffer a similar fate to her.
She wrote: “I’ll always be here for you no matter what, just don’t get pregnant at the age of 14.”
Tasnim has also read harrowing court transcripts from the murder trial, which showed Lucy lived in fear of Mehmood’s repeated abuse.
Just a week before the fire, he forced himself on Lucy at the family home and she screamed for help.
Her dad broke the door down and a neighbour chased Mehmood out. But no one alerted the authorities.
In an emotional exchange, shown in the documentary, Tasnim asks her grandad why he didn’t call the police.
George tells her: “I heard somebody shout, ‘Rape! Rape! Rape!’
“So I went running in, kicked the door down, and next thing you know he was running down the stairs.
“I blame myself for not doing more.”
Tasnim said: “I just think it’s sad because she was suffering. I think she was ignored and she wasn’t listened to.
"If people had intervened when they heard about the rape allegation, he could have been in prison. Nobody listened and she was murdered.”
A spokesman for West Mercia Police said: “We understand the concerns raised but we cannot disclose information that would constitute someone’s personal data.

- Why Dad Killed Mum: My Family’s Secret will be available on BBC Three on iPlayer at 10am on November 13 and BBC1 at 10.35pm the same day.
Triple murderer Azhar Ali Mehmood could be out of jail before Christmas, the Sunday Mirror can reveal.
He is held in low-security HMP Featherstone, Staffs, where offenders are often sent before release.
Mehmood has served 18 years but has refused to admit his guilt for starting the fire which killed Lucy Lowe, her sister and her mum.
A Parole Board hearing will be held next week to rule on his release.

She said: “I hope the Parole Board does what’s best for my family. When you consider the murders and the sex crimes, I don’t think 18 years is long enough.
"I hope whatever the outcome is, myself and my grandad are happy and feel safe.”
The board is expected to deliver its decision by the end of the month.
Insiders say the fact Mehmood has not accepted responsibility will not be an automatic barrier to freedom.
The Lowes can appeal any decision to free him – as can the Ministry of Justice.
And a source added: “Even if not judged fit for release, he could be transferred to an open jail, meaning he’d spend time in the community.”
A Parole Board spokesman said: “A panel will consider evidence before making its decision, with great care and with public safety the priority.”


class: center, middle ### W4995 Applied Machine Learning # Neural Networks in Practice 04/18/18 Andreas C. Müller ??? HW: don't commit cache! Don't commit data! Most <1mb, some 7gb. Say something about GPUs. FIXME update with state-of-the-art instead of VGG16 FIXME slide full vs valid vs same convolutions FIXME update syntax conv2d! FIXME doc screenshots resolution FIXME densenet FIXME resnet FIXME new convnet architectures FIXME move batch-norm before conv-nets FIXME add slide on imagenet? FIXME y_i in batch normalization confusing. FIXME add something about data augmentation FIXME move deconvolutions back (or remove and just do distil paper) FIXME show how permuting pixels doesn't affect fully connected network, but does affect convolutional network --- class:center,middle #Introduction to Keras ??? --- #Keras Sequential .smaller[ ```python from keras.models import Sequential from keras.layers import Dense, Activation ``` ``` Using TensorFlow backend. ``` ```python model = Sequential([ Dense(32, input_shape=(784,)), Activation('relu'), Dense(10), Activation('softmax')]) # or model = Sequential() model.add(Dense(32, input_dim=784)) model.add(Activation('relu')) # or model = Sequential([ Dense(32, input_shape=(784,), activation='relu'), Dense(10, activation='softmax')]) ``` ] ??? There are two interfaces to keras, sequential and the functional, but we’ll only discuss sequential. Sequential is for feed-forward neural networks where one layer follows the other. You specify the layers as a list, similar to a sklearn pipeline. Dense layers are just matrix multiplications. Here we have a neural net with 32 hidden units for the mnist dataset with 10 outputs. The hidden layer nonlinearity is relu, the output if softmax for multi-class classification. You can also instantiate an empty sequential model and then add steps to it. For the first layer we need to specify the input shape so the model knows the sizes of all the matrices. The following layers can infer the sizes from the previous layers. --- .smaller[ ```python model.summary() ``` ] .center[ ![:scale 100%](images/model_summary.png) ] ??? FIXME parameter calculation! model.summary() gives you information about all the layers you have. Checking the summary allows you to see if you’ve assembled the model in the way that you wanted to. So once you assemble this keras model, you need to compile it. --- # Setting Optimizer .center[ ![:scale 90%](images/optimizer.png) ] .smaller[ ```python model.compile("adam", "categorical_crossentropy", metrics=['accuracy']) ``` ] ??? Compile method picks optimization procedure and loss Which basically just means setting some option for the optimizer, this will then give you the compute graph models. Each of parameters can be either a string or you can provide a callable or like an object that implements the right interface. The metrics here are just for monitoring. --- # Training the model .center[ ![:scale 100%](images/training_model.png) ] ??? Fit gets many parameters, not as in sklearn. --- #Preparing MNIST data .smaller[ ```python from keras.datasets import mnist import keras (X_train, y_train), (X_test, y_test) = mnist.load_data() X_train = X_train.reshape(60000, 784) X_test = X_test.reshape(10000, 784) X_train = X_train.astype('float32') X_test = X_test.astype('float32') X_train /= 255 X_test /= 255 print(X_train.shape[0], 'train samples') print(X_test.shape[0], 'test samples') num_classes = 10 # convert class vectors to binary class matrices y_train = keras.utils.to_categorical(y_train, num_classes) y_test = keras.utils.to_categorical(y_test, num_classes) ``` ``` 60000 train samples 10000 test samples ``` ] ??? Running it on MNIST. To use the labels with keras, you need to convert them to one hot encoding. The output layer is 10-dimensional and each of the dimension corresponds to one of the possible outputs. Since the number of classes is 10, this will give 60,000x10 labels for the training set and 10,000x10 labels for the test set. --- # Fit Model ```python model.fit(X_train, y_train, batch_size=128, epochs=10, verbose=1) ``` .center[ ![:scale 80%](images/model_fit.png) ] ??? Once I set up, I can call fit. Each epoch tells you the loss and the accuracy. Loss is the thing that’s actually optimizing. Here, I didn’t specify a validation set so the accuracy is the training set accuracy. So if I gave it a bigger model, and let it run long enough then the accuracy become 1. This model is probably too small to overfit everything. Question is, why I scaled between 0 and 1 instead of mean 0 and standard deviation 1? There are 3 reasons for that. First, that’s what people do. Secondly, the minimum and maximum value mean something, they mean, black and white and so having them as 0 and 1, is kind of meaningful. Thirdly, the different pixels have the same scale. Each of them should be between 0 and 255. But actually, in the dataset, they have different variances, some pixels on the outside are constant white and so if I want to scale them to standard deviation one, I would get division by zero. I could maybe fix that, but there's some that are like slightly gray sometimes and so this would be scaled up enormously, even though that doesn’t really mean a lot. So I kind of used my prior knowledge saying, all these pixels should have the same scale and so I scaled them all in the same way. --- #Fit with Validation ```python model.fit(X_train, y_train, batch_size=128, epochs=10, verbose=1, validation_split=.1) ``` .center[ ![:scale 100%](images/validation_fit.png) ] ??? This is with the validation set. This is very similar to scikit-learn, only you have more options than fit. --- #Evaluating on Test Set ```python score = model.evaluate(X_test, y_test, verbose=0) print("Test loss: {:.3f}".format(score[0])) print("Test Accuracy: {:.3f}".format(score[1])) ``` ``` Test loss: 0.120 Test Accuracy: 0.966 ``` ??? --- # Loggers and Callbacks .smaller[ ```python history_callback = model.fit(X_train, y_train, batch_size=128, epochs=100, verbose=1, validation_split=.1) pd.DataFrame(history_callback.history).plot() ``` ] .center[ ![:scale 70%](images/logger_callback_plot.png) ] ??? We can actually look a little bit deeper into what's happening using callbacks. Keras has very powerful callbacks to do things like early stopping. By default, it just records the history of what happens. These callbacks are returned from the model.fit() History callback has an attribute called history which has all the data of what happened during training. Accuracy on a training set goes up all the time while the loss on the training set goes down all the time. Accuracy in the validation set stops and stays stable after a certain point. The loss on the validation set actually gets worse. So the loss overfits while accuracy doesn't overfit. This gives you a lot of information to debug and check if overfitting happening, how long does it take to train, should you train longer? This interface is pretty simple and pretty similar to scikit-learn but it’s not entirely compatible but sometimes you want to use these Keras models with scikit-learn tools like grid search CV or cross-validation or pipeline. --- #Wrappers for sklearn .smaller[ ```python from keras.wrappers.scikit_learn import KerasClassifier, KerasRegressor from sklearn.model_selection import GridSearchCV def make_model(optimizer="adam", hidden_size=32): model = Sequential([ Dense(hidden_size, input_shape=(784,)), Activation('relu'), Dense(10), Activation('softmax'), ]) model.compile(optimizer=optimizer,loss="categorical_crossentropy", metrics=['accuracy']) return model clf = KerasClassifier(make_model) param_grid = {'epochs': [1, 5, 10], # epochs is fit parameter, not in make_model! 'hidden_size': [32, 64, 256]} grid = GridSearchCV(clf, param_grid=param_grid, cv=5) grid.fit(X_train, y_train) ``` ] ??? See https://keras.io/scikit-learn-api/ Useful for grid-search. You need to define a callable that returns a compiled model. You can search parameters that in Keras would be passed to “fit” like the number of epochs. Searching over epochs in this way is not necessarily a good idea, though. Keras also has wrappers to scikit-learn. These objects behave exactly like scikit-learning objects. To use these, you need to define a function that would return the model. I can then give the make model function to the Keras classifier. The CLF behaves like a scikit-learn estimator. And this enables me to grid search things. I can grid search the parameters of this make model function. So I can grid search, for example, the hidden size. But I could have arbitrary Python code in his make model function. So it could also grid search, what the activations are or how many layers there are or something like that. And you can also grid search the things that are actually part of the fit function in keras. So if you remember the number of epochs was part of fit in keras. But for the keras classifier, it's obviously part of the constructor because it's a scikit-learn API. So you could search both over the fit parameters and over the parameters of the make model function. In practice, maybe grid searching number of epochs is not the smartest thing to do. Maybe looking at the validation set is better. But these are things you could do. And now I can use grid search CV with the keras classifier object, parameter grid, and cross-validation. And everything is, as you would expect. For later homework, doing cross-validation might be too slow for any of the bigger nets. So you could still do this if you set CV to something like stratified shuffle split and do a single split of the data. Stratified shuffled split and iterate equal to one is basically the same as using a single validation holdout set and you can use this for grid search if you want. --- .smaller[ ```python res = pd.DataFrame(grid.cv_results_) res.pivot_table(index=["param_epochs", "param_hidden_size"], values=['mean_train_score', "mean_test_score"]) ``` ] .center[ ![:scale 70%](images/keras_api_results.png) ] ??? Training longer overfits more and more units overfit more, but both also lead to better results. We should probably train much longer actually. Setting the number of epochs via cross-validation is a bit silly since it means starting from scratch again each time. Using early stopping would be better. --- class: middle # Drop-out ??? Drop out is a technique that’s relatively new compared to all the other things. It's a particular way to regularize the network, which cannot be done with scikit-learn. --- # Drop-out Regularization .center[ ![:scale 65%](images/dropout_reg.png) ] ??? For each sample, during training, you actually remove certain hidden nodes. So basically, you just X out the activations. You do this every time you trade over a training sample anew. So, this will be different for every example. The idea at the very high level is to add noise into the training procedure so that you basically make it harder to overfit. Since you drop out these parts, it gets much harder for the model to learn the training set by heart because you always remove different information. The goal is that you then learn weights that are more robust and since you're trying to prevent overfitting that possibly generalizes better. The dropout rate is often pretty high, sometimes it 50%, which means you set 50% of your units to zero. This is only during learning. You only want to add noise in the learning process. When you want to do predictions, you use all the weights but down weight them by the drop out rate. Here, we're not only perturbing the input image, but we're also perturbing the hidden units in a very particular way. As it turns out that actually works much better than just adding noise to the input. --- - https://www.cs.toronto.edu/~hinton/absps/JMLRdropout.pdf - Rate often as high as .5, i.e. 50% of units set to zero! - Predictions: use all weights, down-weight by rate ??? - Randomly set activations to zero. Drop out is a very successful regularization technique developed in 2014. It is an extreme case of adding noise to the input, a previously established method to avoid overfitting. Instead of adding noise, we actually set given inputs to 0. And not only on the input layer, also the intermediate layer. For each sample, and each iteration we pick different nodes. Randomization avoids overfitting to particular examples. --- class:spacious #Ensemble Interpretation - Every possible configuration represents different network. - With p=.5 we jointly learn `$\binom{n}{n/2}$` networks - Networks share weights - For last layer dropout: prediction is approximate geometric mean of predictions of sub-networks. ??? --- #Implementing Drop-Out .smaller[ ```python from keras.layers import Dropout model_dropout = Sequential([ Dense(1024, input_shape=(784,), activation='relu'), Dropout(.5), Dense(1024, activation='relu'), Dropout(.5), Dense(10, activation='softmax'), ]) model_dropout.compile("adam", "categorical_crossentropy", metrics=['accuracy']) history_dropout = model_dropout.fit(X_train, y_train, batch_size=128, epochs=20, verbose=1, validation_split=.1) ``` ] ??? --- class:spacious # When to use drop-out - Avoids overfitting - Allows using much deeper and larger models - Slows down training somewhat - Wasn’t able to produce better results on MNIST (I don’t have a GPU) but should be possible ??? This is basically a regularizer. You're can learn much, much bigger networks with drop out so you can do deeper and wider networks without overfitting. That was the original intent. It slows down training even for the same size because you basically zero out a portion of the weights and these weights will not be updated. And so you need to do more iterations before you've learned all the weights. The question was, can we paralyze over different networks. It's not really implemented as different networks, it's more helpful to think of it as different networks. There are way too many networks as to store them separately. Generally, drop out is one of the techniques that people use that usually improve generalization and decrease overfitting. Another technique that you should look up is residual networks. It’s another generic strategy to speed up training and it allows to learn deeper networks. Not all state of the art neural networks you will see use drop out, but some of them might. And similarly, you will see some that use residual networks or batch normalization. There’s basically a toolbox of different tricks that people use and plot together to get good networks. Another technique that is often used with neural networks is augmenting the training data. So adding noise to training data, or changing the training data in some way so that you get more data is something that is often very helpful. We'll talk about images next. With natural images, you can flip it on the y-axis and it will still semantically be the same image unless you want to do OCR. And so if you do that, you just doubled the size of your training set. And for neural networks, the bigger training set, the better. If you do something like add noise, this actually gives you an infinite sized training set because every time you see a sample, you add noise in a different way and so you on the fly, generate arbitrarily big training datasets. Drop out is sort of a way to do this generically and do this on the hidden layer. But if you have domain knowledge, like for images, and you can do this in a way that's specific to the domain, then that is often more helpful. Another thing that is used with images, for example, is looking at different crops/scales of the image. So if you can crop your image in different ways, like 3 pixels to left and 3 pixels to the right and each of them is a new training sample, this way, you can also get infinitely many samples. Obviously, they're all correlated but it's better than just using the same sample over and over and makes overfitting harder. And these are actually very, very important techniques. So if you look at state of the art models they will always use these techniques to augment the training dataset, because getting images is easy, for example, but getting labeled images is very hard.  If you're just doing classification and cropping it differently or rotating, it will not change the label. Unless your label is a person holding something in the left hand versus holding something in the right hand and then you know you need to switch the label. --- class:center,middle #Convolutional neural networks ??? --- class:spacious # Idea - Translation invariance - Weight sharing ??? FIXME figure with illustration There are 2 main ideas. One is if you move your focus of an image, the semantics of the image are the same. So if I look a little bit further right a pixel or so then this shouldn't really change my interpretation of the image. It also implies if I detect something on the right side, it's sort of the same as detecting something in the left side, for many natural image tasks. So if I want to say is there’s a person in the image, it doesn't matter if the person is in the left, right, top or bottom, detecting a person will always be the same thing. Weight sharing is that basically, you can detect something no matter where it is in an image. --- #Definition of Convolution `$$ (f*g)[n] = \sum\limits_{m=-\infty}^\infty f[m]g[n-m] $$` `$$ = \sum\limits_{m=-\infty}^\infty f[n-m]g[m] $$` .center[ ![:scale 80%](images/convolution.png) ] ??? The definition is symmetric in f, but usually one is the input signal, say f, and g is a fixed “filter” that is applied to it. You can imagine the convolution as g sliding over f. If the support of g is smaller than the support of f (it’s a shorter non-zero sequence) then you can think of it as each entry in f * g depending on all entries of g multiplied with a local window in f. Not that the output is shorter than the input by half the size of g. this is called a valid convolution. We could also extend f with zeros, and get a result that is larger than f by half the size of g, that’s called a full convolution. We can also just pad a little bit and get something that is of the same size as f. Also not that the filter g is flipped as it’s indexed with -m It’s easier to think about this in a signal processing context, where we have some signal, and you have a filter that you want to apply to the signal. --- #1d example: Gaussian smoothing .center[ ![:scale 80%](images/Gaussian_Smoothing.png) ] ??? This is how it looks in a 1D dataset. I can try to smooth this signal out by, for example, using a Gaussian filter. So here, the top left would be F and the top right would be G. Computing the convolution between F and G basically means each point in the new series is a Gaussian weighted average of the surrounding points. The result I get is displayed in the bottom. So smoothing is one of the simplest things we can do with convolutions. --- #2d Smoothing .center[ ![:scale 80%](images/2dsmoothing.png) ] ??? This can also be done in 2D. --- #2d Gradients .center[ ![:scale 80%](images/2dgradient.png) ] ??? Gradients can be computed with convolutions. One way to compute a smooth gradient on the image is using this filter. After applying the filter I get vertical edges on a particular scale. Whereas the areas which are of the same color are smooth. You can also compute Laplacian, and you can detect simple parent images. So what a convolution neural network does is, most layers apply convolutions of this form and what we want to learn are these entries in these filters. In convolutional neural network, the weights that I'm going to learn are not weights to multiply, but it's these filters that apply all the image. And so by this, you get the two things that we want which are translation invariance and being invariant to location. Since the same filters are applied everywhere, detecting an edge at the top, it's the same as detecting an edge at the bottom. And because of the way that this is computed, if I shift the image by one pixel, the output shifts by one pixel, but the correspondence between input and output will stay the same. --- #Convolution Neural Networks .center[ ![:scale 100%](images/CNET1.png) ] - Y. LeCun, L. Bottou, Y. Bengio, and P. Haffner. - Gradient-based learning applied to document recognition ??? Here is the architecture of an early convolutional net form 1998. The basic architecture in current networks is still the same. You can multiple layers of convolutions and resampling operations. You start convolving the image, which extracts local features. Each convolutions creates new “feature maps” that serve as input to later convolutions. To allow more global operations, after the convolutions the image resolution is changed. Back then it was subsampling, today it is max-pooling. So you end up with more and more feature maps with lower and lower resolution. At the end, you have some fully connected layers to do the classificattion. --- .center[ ![:scale 60%](images/cnn_digits.png) ] ??? These are the activations. --- # Deconvolution .center[ ![:scale 100%](images/deconvolution_1.png) ] https://www.cs.nyu.edu/~fergus/papers/zeilerECCV2014.pdf ??? If you do it on natural images, you get something like this. This is one of the standard neural networks trained on image net dataset. So you can look at the filters in the input layer and because they're in image space, you can just visualize them. Here, this network has 9 filters in the first layer. If you look at the higher layers, if you want to see the filters, it's kind of hard, because they don't work on the input space, they work on the space created by these filters. But you can kind of try to project them down into the original image. And if you do that, then you get something like these. So this is sort of a visualization of what the second layer learned, this is sort of what they try to detect in the input. And for each of these, here, you can see the patches in the training set that most corresponded to them. --- class: center, middle ![:scale 100%](images/deconvolution_2.png) ??? The goal is that with each layer going up, it learns more and more abstract things. And so these are different units in the dataset and what they correspond to. This network learned to detect people even though there’s no person class in image net. --- class: center, middle ![:scale 100%](images/deconvolution_3.png) ??? If you go even deeper into the network, you can see that the units correspond to even more abstract things. These are all learned for the class of image classification. So this was just trained on the output, there was no information about the location of anything in the image, it was just trained. The dogs in these images are of different breeds and different vehicles, and so on. So there was never any location information in the training, but it's still picked up a lot of things. --- #Max Pooling .center[ ![:scale 100%](images/maxpool.png) ] ??? - Need to remember position of maximum for back-propagation. - Again not differentiable → subgradient descent One of the many things that changed since the research paper MNest is that, instead of averaging, we're now doing max pooling usually. Looking at the 4x4 pixels, instead of subsampling, subsampling basically means just average them, what people are doing now is just taking the maximum. So this is again, used to reduce the size of the input. For example, if we do 2x2 non-overlapping max pooling, we go from 4x4 to 2x2. And people also sometimes do like bigger max pooling, overlapping max pooling, and there are many different variants of what you can do. But people now usually use max pooling for decreasing the resolution. If you do this, this is not differentiable, again, similar to the relu. Again, you need to do separating descend but in reality, you don't really need to worry about it. If you want to do gradient descent, you need to store where the maximum came from, though. If you just store the output, you can’t backpropagate through it, you need to know that the 20 came from here. Q: Can we take the minimum instead of the maximum? Probably no if you're using rectified linear units because the minimum will usually be zero, it caps at zero. If you use tan-H, it should be all symmetric and probably doesn't matter. --- .center[ ![:scale 80%](images/other_architectures.png) ] ??? Here are two more recent architectures, AlexNet from 2012 and VGG net from 2015. These nets are typically very deep, but often have very small convolutions. In VGG there are 3x3 convolutions and even 1x1 convolutions which serve to summarize multiple feature maps into one. There is often multiple convolutions without pooling in between but pooling is definitely essential. --- class:center,middle #Conv-nets with keras ??? --- #Preparing Data .smaller[ ```python batch_size = 128 num_classes = 10 epochs = 12 # input image dimensions img_rows, img_cols = 28, 28 # the data, shuffled and split between train and test sets (x_train, y_train), (x_test, y_test) = mnist.load_data() X_train_images = x_train.reshape(x_train.shape[0], img_rows, img_cols, 1) X_test_images = x_test.reshape(x_test.shape[0], img_rows, img_cols, 1) input_shape = (img_rows, img_cols, 1) y_train = keras.utils.to_categorical(y_train, num_classes) y_test = keras.utils.to_categorical(y_test, num_classes) ``` ] ??? For convolutional nets the data is n_samples, width, height, channels. MNIST has one channel because it’s grayscale. Often you have RGB channels or possibly Lab. The position of the channels is configurable, using the “channels_first” and “channels_last” options – but you shouldn’t have to worry about that. --- # Create Tiny Network ```python from keras.layers import Conv2D, MaxPooling2D, Flatten num_classes = 10 cnn = Sequential() cnn.add(Conv2D(32, kernel_size=(3, 3), activation='relu', input_shape=input_shape)) cnn.add(MaxPooling2D(pool_size=(2, 2))) cnn.add(Conv2D(32, (3, 3), activation='relu')) cnn.add(MaxPooling2D(pool_size=(2, 2))) cnn.add(Flatten()) cnn.add(Dense(64, activation='relu')) cnn.add(Dense(num_classes, activation='softmax')) ``` ??? For convolutional nets we need 3 new layer types: Conv2d for 2d convolutions, MaxPooling2d for max pooling and Flatten go reshape the input for a dense layer. There are many other options but these are the most commonly used ones. --- #Number of Parameters .left-column[ Convolutional Network for MNIST ![:scale 100%](images/cnn_params_mnist.png) ] .right-column[ Dense Network for MNIST ![:scale 100%](images/dense_params_mnist.png) ] ??? Convolutional networks have many more activations but they have fewer weights to learn because they’re shared everywhere. --- #Train and Evaluate .smaller[ ```python cnn.compile("adam", "categorical_crossentropy", metrics=['accuracy']) history_cnn = cnn.fit(X_train_images, y_train, batch_size=128, epochs=20, verbose=1, validation_split=.1) cnn.evaluate(X_test_images, y_test) ``` ``` 9952/10000 [============================>.] - ETA: 0s [0.089020583277629253, 0.98429999999999995] ``` ] .center[ ![:scale 50%](images/train_evaluate.png) ] ??? You get some overfitting but generally, the results are pretty decent. --- #Visualize Filters .smaller[ ```python weights, biases = cnn_small.layers[0].get_weights() weights2, biases2 = cnn_small.layers[2].get_weights() print(weights.shape) print(weights2.shape) ``` ``` (3,3,1,8) (3,3,8,8) ``` ] .center[![:scale 40%](images/visualize_filters.png)] ??? These are the filters in the first layer, I learned 8 3x3 filters. This makes to 8 maps, meaning 64 filters. Each row corresponds to one output map. --- .center[![:scale 80%](images/digits.png)] ??? --- class:center,middle # Batch Normalization ??? The next thing I want to talk about is one more trick that we can use to improve learning called batch normalization. This is a heuristic people found that speeds up learning and often gives better results. The idea here is that you want the hidden units to be scaled well. So what this does is kind of trying to scale hidden units to zero mean unit variance and doing this per batch. --- #Batch Normalization .center[ ![:scale 80%](images/batch_norm.png) ] .smallest[ [Ioffe, Szegedy: Batch Normalization: Accelerating Deep Network Training by Reducing Internal Covariate Shift](https://arxiv.org/abs/1502.03167) ] ??? Another relatively recent advance in neural networks is batch normalization. The idea is that neural networks learn best when the input is zero mean and unit variance. We can scale the data to get that. But each layer inside a neural network is itself a neural network with inputs given by the previous layer. And that output might have much larger or smaller scale (depending on the activation function). Batch normalization re-normalizes the activations for a layer for each batch during training (as the distribution over activation changes). The avoids saturation when using saturating functions. To keep the expressive power of the model, additional scale and shift parameters are learned that are applied after the per-batch normalization. --- # Convnet with Batch Normalization .smaller[```python from keras.layers import BatchNormalization num_class = 10 cnn_small_bn = Sequential() cnn_small_bn.add(Conv2D(8, kernel_size=(3, 3), input_shape=input_shape)) cnn_small_bn.add(Activation("relu")) cnn_small_bn.add(BatchNormalization()) cnn_small_bn.add(MaxPooling2D(pool_size=(2, 2))) cnn_small_bn.add(Conv2D(8, (3, 3))) cnn_small_bn.add(Activation("relu")) cnn_small_bn.add(BatchNormalization()) cnn_small_bn.add(MaxPooling2D(pool_size=(2, 2))) cnn_small_bn.add(Flatten()) cnn_small_bn.add(Dense(64, activation='relu')) cnn_small_bn.add(Dense(num_classes, activation='softmax')) ```] ??? very small to make it fit on a slide --- # Learning speed and accuracy .center[![:scale 80%](images/learning_speed.png) ] ??? FIXME label axes! The solid lines are with batch normalization and the dotted lines are without batch normalization. You can see the learning is much faster and also gets to a better accuracy. --- # For larger net (64 filters) .center[![:scale 80%](images/learning_speed_larger.png) ] ??? FIXME label axes Here's the same thing with a larger network where we have 64 filters instead of 8. This learns even faster and learns to overfit really well. --- class: middle # Questions ?


10-May-2017 | Milku
If Daft Punk can do it...
Maybe I'll get lucky and finally gnaw a hole in my exercise box.
Well, it’s 10th May and you all know what that means, don’t you? Well, you should. It’s time for you to get in touch with your inner hamster…it’s ‘Stay up All Night’ Night. Actually, I’m not too sure I agree with it. I don’t really want any company. You won’t think I’m contrary if I don’t take part, will you? I feel like I might need a little nap.
I had a lot of excitement yesterday evening hearing all about the fundraiser that the Rainbows, Brownies and Guides put on for St Mary’s church. I noticed that they brought home a few things for themselves, but they didn’t think about bringing me a cake.
However, the Food Technology class in the high school did provide me with a tasty treat of savoury rice. My little humans wouldn’t have it for dinner because it contained vegetables. They don’t know what they missed. My compliments to the St Mary's Food Tech teacher…


Olivier Giroud's demands too high for Inter Milan?
Inter Milan are currently against meeting the demands of Chelsea forward Olivier Giroud, according to a report.
by Darren PlantAfter falling down the pecking order at Stamford Bridge, Giroud is expected to sign for a new club during the January transfer window.
Inter are currently regarded as the World Cup winner's most likely destination due to the player having previously worked with head coach Antonio Conte.
However, according to La Gazzetta dello Sport, the Italian giants are some way from agreeing terms with the 33-year-old.
The report claims that Giroud would need to take a pay cut in order to secure a switch to San Siro.
The France international is also said to be keen on receiving a two-and-a-half year deal, 12 months longer than Inter are prepared to offer the frontman.
body check tags ::


Open source UI components and visual style guide to create consistency and
beautiful user experiences.
In order to achieve this, we need to have a single point of reference for all
the patterns we use, so that everyone internally can refer to them.
We also need a shared vocabulary of UI elements and code, to allow teams
to communicate with each other in the most efficient way.
We created this pattern library with several goals in mind:
This is a “living document” and should be updated when the code underlying the feature changes or when a new pattern is introduced.


The Trident engine is used by Microsoft in their Internet Explorer browsers. It has become out of date with web standards, so the below table highlights some major differences between Trident and today's more commonly used rendering engine, WebKit.
Microsoft's latest browser, Edge, uses a fork of Trident, called EdgeHTML, which follows web standards more closely.


--- title: forms-m section_title: Forms section_id: forms ---
Examples of what we have right now
{% include touchforms/html5_types.md %} {% include touchforms/radio.md %} {% include touchforms/checkbox.md %} {% include touchforms/select.md %} {% include touchforms/textarea.md %}


|
|
IFXLightResource Class ReferenceThe IFXLightResource object encapsulates a light properties.
More...
Inheritance diagram for IFXLightResource:
List of all members.
Detailed Description
The IFXLightResource object encapsulates a light properties.
The light can be one of four types:
- Ambient: The light provides uniform non-directional light to all objects in the visible scene.
- Point: The light has a specific light source located at the center of it's local coordinate space.
- Directional: The light affects all object of the scene uniformly. Light from this source appears to each object as coming from the same direction relative to the world.
- Spot: The light acts as a spot light, having a distinct location in the world, and only affecting a conical area in the scene relative to that position.
Member Enumeration Documentation
|
|
Enumerant for the various distance attenuation factors.
- Enumerator:
-
| CONSTANT |
Constant attenuation factor (unaffected by distance). |
| LINEAR |
Attenuation factor relative to distance. |
| QUADRADIC |
Attenuation factor relative to distance squared. |
|
|
|
Enumerant for various light attributes.
- Enumerator:
-
| ENABLED |
Whether or not this light is enabled (can be used). |
| SPECULAR |
Whether or not this light provides specular highlights. |
| SPOTDECAY |
Whether or not spotlights have smooth or hard edge cutoffs. |
|
|
|
Light type enumerant for the four light types.
- Enumerator:
-
| AMBIENT |
Light provides uniform non-directional light to the scene. |
| DIRECTIONAL |
Light provides uniform directional light to the scene. |
| POINT |
Light is emitted from a specific point in the scene. |
| SPOT |
Like point light, but constrained to specific directions. |
|
Member Function Documentation
| virtual IFXRESULT IFXAPI IFXLightResource::GetAttenuation |
( |
F32 * |
pOut |
) |
[pure virtual] |
|
|
|
Retrieves the attenuation vector.
This vector contains the Constant, Linear, and Quadratic attenuation factors. Lights that are of type IFXLightResource::POINT or IFXLightResource::SPOT, will light objects based on distance from the object's vertices to the light position. The formula for this attenuation is:
1/(C + Ld + Q(d*d))
where:
- C: Constant attenuation factor
- L: Linear attenuation factor
- Q: Quadratic attenuation factor
The result of this calculation determines the percentage of influence that this light will have on each vertex.
- Parameters:
-
| pOut | An F32 pointer to an array of at least 3 F32 values to be filled in with the Constant, Linear, and Quadratic attenuation factors. |
- Returns:
- An IFXRESULT value.
- Return values:
-
| IFX_OK | No error. |
| IFX_E_INVALID_POINTER | The value of pOut is invalid (NULL). |
Implemented in CIFXLightResource. |
| virtual U8 IFXAPI IFXLightResource::GetAttributes |
( |
void |
|
) |
[pure virtual] |
|
|
|
Gets the light attributes for this light.
- Returns:
- A U8 value. This can be a combination of LightAttributes enumerants.
Implemented in CIFXLightResource. |
| virtual const IFXVector4& IFXAPI IFXLightResource::GetColor |
( |
void |
|
) |
[pure virtual] |
|
|
|
Gets the color of this light.
- Returns:
- An IFXVector4 that contains the RGBA values of the light color, each specified in the range 0.0 - 1.0.
Implemented in CIFXLightResource. |
| virtual F32 IFXAPI IFXLightResource::GetExtent |
( |
void |
|
) |
[pure virtual] |
|
| virtual F32 IFXAPI IFXLightResource::GetIntensity |
( |
|
) |
[pure virtual] |
|
|
|
Retrieves the intensity of the light.
- Note:
- see SetIntensity for more information.
- Returns:
- An F32 value representing the intensity of the light.
Implemented in CIFXLightResource. |
| virtual IFXRenderLight& IFXLightResource::GetRenderLight |
( |
|
) |
[pure virtual] |
|
|
|
Retrieves the underlying IFXRenderLight object for this light.
This is the object that is sent to IFXRenderContext instances to pass along light parameters. It is recommended to use other methods to change light parameters.
- Returns:
- A reference to an IFXRenderLight object.
Implemented in CIFXLightResource. |
| virtual F32 IFXAPI IFXLightResource::GetSpotAngle |
( |
void |
|
) |
[pure virtual] |
|
|
|
Gets the spot angle for this light.
The spot angle is the angle of the cone that emanates from the light position and defines what portions of the scene is affected by this light (assuming it is of type IFXLightResource::SPOT).
- Returns:
- An F32 value representing the spot angle for this light.
Implemented in CIFXLightResource. |
| virtual LightType IFXAPI IFXLightResource::GetType |
( |
void |
|
) |
[pure virtual] |
|
|
|
Retrieves the light type for this light.
- Returns:
- A LightType value.
- Return values:
-
- Returns:
- void
Implemented in CIFXLightResource. |
| virtual IFXRESULT IFXAPI IFXLightResource::SetAttenuation |
( |
F32 * |
pIn |
) |
[pure virtual] |
|
|
|
Sets the attenuation vector.
This vector contains the Constant, Linear, and Quadratic attenuation factors. Lights that are of type IFXLightResource::POINT or IFXLightResource::SPOT, will light objects based on distance from the object's vertices to the light position. The formula for this attenuation is:
1/(C + Ld + Q(d*d))
where:
- C: Constant attenuation factor
- L: Linear attenuation factor
- Q: Quadratic attenuation factor
The result of this calculation determines the percentage of influence that this light will have on each vertex.
The default value is (C,L,Q): (1,0,0)
- Parameters:
-
| pIn | An F32 pointer to an array of at least 3 F32 values that specify what the new Constant, Linear, and Quadratic attenuation factors are. |
- Returns:
- An IFXRESULT value.
- Return values:
-
| IFX_OK | No error. |
| IFX_E_INVALID_POINTER | The value of pIn is invalid (NULL). |
| IFX_E_INVALID_RANGE | The attenuation factors specified are all 0. This would result in a divide by 0 error in the lighting equation. |
Implemented in CIFXLightResource. |
| virtual void IFXAPI IFXLightResource::SetAttributes |
( |
U8 |
uuIn |
) |
[pure virtual] |
|
|
|
Sets the light attributes for this light.
- Parameters:
-
| uuIn | Input U8 that is composed of a number of LightAttributes flags. |
- Returns:
- void
Implemented in CIFXLightResource. |
| virtual void IFXAPI IFXLightResource::SetColor |
( |
IFXVector4 |
vIn |
) |
[pure virtual] |
|
|
|
Sets the color of this light.
- Parameters:
-
| IFXVector4 | Input IFXVector4 specifying the color of the light. Each channel of the light color is clamped to the range 0.0 - 1.0. |
- Returns:
- void
Implemented in CIFXLightResource. |
| virtual IFXRESULT IFXAPI IFXLightResource::SetIntensity |
( |
F32 |
fIn |
) |
[pure virtual] |
|
|
|
Sets the intensity of the light.
This intensity is basically multiplied into the affect that this light has on a scene. It is similar in practice to 1/ConstantAttenuationFactor, but works on IFXLightResource::DIRECTIONAL lights in addition to point and spot lights (this does not affect lights with type IFXLightResource::AMBIENT). Keep in mind that this value can have any value (including negative and 0), resulting in the ability to produce some strange effects.
- Parameters:
-
| fIn | Input F32 value specifying the intensity of this light. |
- Returns:
- An IFXRESULT value.
- Return values:
-
Implemented in CIFXLightResource. |
| virtual void IFXAPI IFXLightResource::SetSpotAngle |
( |
F32 |
fIn |
) |
[pure virtual] |
|
|
|
Sets the spot angle for this light.
The spot angle is the angle of the cone that emanates from the light position and defines what portions of the scene is affected by this light (assuming it is of type IFXLightResource::SPOT).
- Parameters:
-
| fIn | Input F32 specifying the spot angle. This should be the full spot angle (from one side of the cone to the other). The range is 0.0 - 180.0, non-inclusive. |
- Returns:
- void
Implemented in CIFXLightResource. |
| virtual void IFXAPI IFXLightResource::SetType |
( |
LightType |
u8In |
) |
[pure virtual] |
|
|
|
Sets the light type for this light.
- Parameters:
-
| u8In | Input LightType value specifying the light type. This can be one of the following values:
|
- Returns:
- void
|
© 1999 - 2006 Intel Corporation. All rights reserved.
* Other names and brands may be claimed as the property of others.
|
|


Saishunkan System.
Prefecture
City
Building
Company
List of Prefecture
List of City
List of Building
List of Company


Preparation time
less than 30 mins
Cooking time
1 to 2 hours
Serves
Serves 4
Place the mutton shanks in a large saucepan with the turmeric, ginger, garlic and some salt.
Add enough water to cover and simmer gently for 1½ hours or until the meat is tender.
Meanwhile, grind all the curry paste ingredients together in a spice grinder or pestle and mortar. Set aside until required.
For the curry, heat two tablespoons of the sunflower oil in a large deep frying pan and add the bay leaf, cinnamon, cloves and cardamom and fry until aromatic.
Add the onion and fry until it is softened, but not coloured.
Add the tomato and cook for five minutes, then add the cumin, coriander and green chillies and cook for a further three minutes.
Add the curry paste to the frying pan and cook for another two minutes, before adding the cooked mutton, salt to taste and enough of the mutton cooking water to come halfway up the shanks. Cook for another 20 minutes, turning the shanks over several times during cooking and adding more of the mutton cooking water if the sauce gets too thick.
For the rice, heat a frying pan until hot and add the sunflower oil.
Add the mustard seeds and chana dal and fry until they start to pop, taking care as the oil may splatter.
Add the cashew nuts, curry leaves, turmeric, asafoetida and ginger and stir fry for 1-2 minutes.
Finally add the cooked rice and lemon juice and cook until hot all the way through.
Serve the mutton with a spoonful of rice and sprinkle with coriander.


“The lighting of the exposition can barely be touched upon in a few paragraphs and it would be difficult to describe in words even if space were unlimited. It represented the power of light to beautify and to awe… It was a crowning achievement of a century of public lighting which began with Murdock's initial display of a hundred flickering gas-jets… It was a silent but pulsating display of grandeur dwarfing into insignificance the aurora borealis in its most resplendent moments.” — M Luckiesh, Artificial Light


http://christrees.com<EMAIL_ADDRESS>Intent:
Basic HWPC Bug Ticket Tracking Project Template. ==> Go MS - index3.html <== I was attempting to load.
Test:
Site at http://hwpc.azurewebsites.net
Steps:
- Milestone 1: Setup - Goal: Basic HWPC setup- Status: Done
Setup
https://hwpc.visualstudio.com/DefaultCollection/HWPCBug,
https://manage.windowsazure.com, and
http://hwpc.azurewebsites.net
Source Setup
- Create HWPCBug project
-<EMAIL_ADDRESS>- Xxxx2Yyyyyy (owner)
-<EMAIL_ADDRESS>- ?? (dev on CAT_MSWin8Enterprise)
- New checkin - Add all untracked files, Commit 'Initial Commit - MVC 5 out of box', Sync
Azure Setup
- Site at http://hwpc.azurewebsites.net
- Control at https://manage.windowsazure.com under<EMAIL_ADDRESS>- Have azure pull from VSOnline Deploy from Source
- On https://hwpc.visualstudio.com I had to go to Control panel -> Default Collection -> HWPCBug | Security Tab | Member of | and add Build Admin, Contrib, Project Admin and Project Valid Users
- Then make a change in source and do commit 'Add Ticket.cs to kick off build to Azure', which it did and you can see the build in hwpc.vsol under Build - Deployed
- This deployment did not trigger a db change and the old db was for some other code, so I disable the db link at this url and also deleted the db at this url
Test Setup
- ToDo
- Milestone 2: Ticket - Goal: Get Tickets list to display - Status: TODO
Just get a basic site up that hits the old db.
Steps
- New ASP.NET solution WebSite. Commit 'Initial Commit - MVC 5 out of box', Sync
- For Security stuff... Follow along with ASP.NET MVC 5 Fundamentals Identity and Security - Authorize - New Controller: This tells about how to controll Auth in controllers
- For General Follow along with One ASP.NET From Scratch
- MVC - Create default out-of-box
- Controller - Shows basic controller... how to hookup
- View Intro - stuff
- View - Start to mod the display
- in Views/Shared/_Layout.cshtml*
- line 6 change to HWPC Bug
- line 9 change to HWPC Bug
- line 36 change to @DateTime.Now.Year - Hawkeye West Pest Control
- in Views/Home/Contact.cshtml... do a lot of display work...
- Model Intro - stuff
- Model - Start to structure HWPC data
- Created models... then got lost in code... got things working...
- about 10hrs of code messing with MVC 5 / EF / Razor stuff... got prototype going
- Visual Studio Team Checkin -> Milestone 2: Ticket
- Team Explorer -> Changes -> Untraced Files (6) click Add All
- Included Changes (38)
- Commit Message -> Milestone 2: Ticket
- Click Commit
- Sync
- Milestone 2: Ticket - CommitID: c9960ab164c8c1bf28ec3209a6cf48b1f54003e6
- Deploy using hwpc.azurewebsites.net_1_.PublishSettings it deployed but failed to run... thinking it was the db setup
- This runs locally... again, thinking it's the db setup... so I'll setup this local to use local SQL...
- So... mod Web.config to point to a sql db
- remove the initialize from Global.asax
- In HwpcDbInitializer.cs use DropCreateDatabaseIfModelChanges
- Create a load tab file for HwpcRoute C:\Users\Cat\Source\Repos\HWPC_DB_20140223\route_db.txt
- Create new SQL file C:\Users\Cat\Source\Repos\HWPC_DB_20140223\Hwpc_MVC5_CreateAndLoad_FromFiles_SQLQuery9.sql
- Go to https://manage.windowsazure.com under<EMAIL_ADDRESS>- Quick create HwpcDBContext Db
- Unlink hwpcbugticketdb from hwpc website, Link HwpcDBContext (cathwpc - Time2Invest)
- Update the Web.Config connection string to point to correct online db
- ... still getting error... I have to move so need to 'suspend'
- ... ok... after lots of hacking over a few days... basically need to scorched earth azure...
- I also hacked around with CSS and Auth stuff to get basic auth going
- Deploy Online Site at http://hwpc.azurewebsites.net
- Go to https://manage.windowsazure.com under<EMAIL_ADDRESS>- Nuke hwpc Site and HwpcDBContext SQL
- Right Click on HwpcDBContext in MS SQL Management Studio -> Tasks -> Deploy Database to SQL Azure
- Follow Wizard (connect to Azure cathwpc - Time2Invest)
- Go to VS and Deploy Website to hwpc
- That works... snap a version
- Visual Studio Team Checkin -> Milestone 2: Ticket Deploy to hwpc
- Team Explorer -> Changes -> Untraced Files (0) click Add All
- Included Changes (23)
- Commit Message -> Milestone 2: Ticket Deploy to hwpc
- Click Commit
- Sync
- Milestone 2: Ticket Deploy to hwpc - CommitID: 57abcab0a47dc9bc15094b2d94ab966a2ae36e17
- Now work on CSS to get printing to work
- Get icon stuff going again... shortcut icon for desktop metro.. publish
- New Commit
- Visual Studio Team Checkin -> Milestone 2: Ticket CSS Stuff
- Team Explorer -> Changes -> Untraced Files (0) click Add All
- Included Changes (23)
- Commit Message -> Milestone 2: Ticket CSS Stuff
- Click Commit
- Sync
- Milestone 2: Ticket Deploy to hwpc - CommitID: 039f55608f17236c93ea0f8fbfb113f3c74e681e
- Git this document up on catmini
- Post on cat9.com
THE END
CAT NOTES:
- http://localhost:2211/QBSDK13.0/doc/html/GettingStarted.html
- https://developer.intuit.com/docs/0250_qb/0040_get_building
- https://developer.intuit.com/docs/0250_qb/0020_get_set_up/sdk_downloads
- http://i861.photobucket.com/albums/ab179/mittou/34/W7X94_02.jpg
- http://www.bootply.com/103783
- http://www.sitepoint.com/create-invoice-twitter-bootstrap-part-1/
- http://www.sitepoint.com/create-invoice-twitter-bootstrap-part-2/
- http://www.codeproject.com/Tips/686270/Generate-Dynamic-Autocomplete-Feature-to-a-Textbox
- http://www.codeproject.com/Tips/686270/Generate-Dynamic-Autocomplete-Feature-to-a-Textbox


{%if email_address%}
Welcome to our site, {{email_address}}! Please sign up and enter username below.
Sign Out
{%else%}
Serve Up, Speak Up
Sign In
{%endif%}


French toast is undoubtedly one of the most popular breakfast foods in the Western world. It is usually made by soaking a slice of bread in a mixture of milk and eggs before frying it in a skillet or pan. If you are one of the many people who regularly enjoy French toast in the morning then you probably want to know the nutrition behind this food.
It's simple, it's adjustable, it can be hot and bland, or sweet and fruity! It's incredible, it's edible, it's French Toast!
A classic breakfast food, it's incredibly easy to prepare, and can be made to suite tastes! Fresh fruit, powdered sugars, syrups, or even just plain and buttery! It's really all about the customization, as French Toast is nearly impossible to cook wrong!
Enjoy your foray into the world of French Toast!


Pollination Ecology of the Simultancously Flowering Impatiens capensis and J. pallida by John L. Randall, Jr.
Dissertation submitted to the Faculty of the Virginia Polytechnic Institute and State University in partial fulfillment of the requirements for the degree of Doctor of Philosophy in
Botany
APPROVED:
Khidir W. Hilu, Chairman
Duncan M. Porter ~~ David A. West
Richard D. Fell Golde |-Molizman
May, 1988 Blacksburg, Virginia


Celebrating diversity in B.C.
by Sarita PatelBritish Columbia proclaimed the third week of November as Multiculturalism Week which is celebrated yearly.
"B.C. Multiculturalism Week celebrates the ways our lives are made better by the incredible diversity of the people in our province. I am so grateful to live in a place where people from all over the world have chosen to put down roots and share their cultures with each other, explains Anne Kang, Parliamentary Secretary for Multiculturalism.
Passed in 1993, British Columbia’s Multiculturalism Act was built on the aspiration of creating a multicultural society free from racism, where individuals are treated with respect and dignity and all British Columbians have equal opportunity to participate in the community.
"As a first-generation Canadian, I realize the courage it takes for people to leave their homes behind in search of new opportunities and a better life for their families. Today, we are so lucky to be able to experience the cultural mosaic of a province that is home to people who trace their origins to more than 200 countries or regions," adds Kang.
As the most ethnically diverse province in Canada, B.C. is home to 204 First Nations, vibrant Metis and urban Indigenous communities and residents who trace their origins to more than 200 countries or regions.
"This Multiculturalism Week, I encourage everyone in B.C. to find ways to learn about and build connections with people from cultures and backgrounds different from their own," says Kang.
Kang is B.C.'s newly appointed parliamentary secretary for multiculturalism and says she is committed to doing everything I can to uphold and protect B.C.'s cultural diversity.
"When I think about the future, I am filled with hope that our children will grow up in a world where everyone feels valued and respected."
"I hope you will join me in celebrating Multiculturalism Week in B.C. and stand with us as we work to create to a province that is open, welcoming and inclusive, and free of racism, hate and discrimination."


WITNESS LIST Redistricting Committee March 20, 2001-6:00P Redistricting On: Murdock, Dr. Steve (Texas State Data Center)


Here in 1771, an armed rebellion of backcountry farmers called Regulators battled with royal governor William Tryon's militia. The spark for this conflict was growing resentment in the Carolina colony against the taxes, dishonest sheriffs, and illegal fees imposed by the British Crown. In response, the Regulators were formed and began to fight back. Though the rebellion was crushed, a few years later their tactics became a model for the colonists fighting the British in the American Revolutionary War. Google Maps search - 5803 N Carolina 62, Burlington, NC 27215
Battle of Cowpens, fought on January 17, 1781, an American victory over a British force on the northern border of South Carolina that slowed Lord Cornwallis’s campaign to invade North Carolina. The British lost 39 officers and 60 soldiers killed. 829 were captured. 12 Americans were killed and 60 wounded. Google Maps search - 4001 Chesnee Hwy, Gaffney, SC 29341
The 1781 Battle of Guilford Courthouse, while technically a British victory, cost the British so many casualties that Lord Cornwallis ceased his attempt to retake North Carolina. The modern national military park is within the city of Greensboro, which is part of the Winston-Salem metro area in west-central North Carolina. From downtown Greensboro, head north on US 220 -- Battleground Avenue -- to Old Battleground Road, which goes directly to the park. The park is large enough to tour by car, along a one-way road that passes seven tour stops that describe the battle. Google Maps search - 2332 New Garden Rd, Greensboro, NC 27410
The battle of Kings Mountain, fought October 7th, 1780, was an important American victory during the Revolutionary War. The battle was the first major patriot victory to occur after the British invasion of Charleston, SC in May 1780. It was one of the few major battles of the war fought entirely between Americans: no British troops served here. The battle lasted about one hour. Americans lost 28, Loyalists lost 225 and 716 were captured. The dead were buried on the battlefield in unmarked graves, they have never been found. King's Mountain saved North Carolina for the time being and bolstered Patriot morale throughout the 13 colonies. Google Maps search - 2625 Park Rd, Blacksburg, SC 29702
Relatively little known, Ramsour's Mill Battleground is historic as an important battle between the Americans and the British (the Americans won). To reach Ramsour's Mill from the Charlotte area, follow US 321 north to Lincolnton, North Carolina. From downtown Lincolnton, follow North Aspen Street until making a left on Paul Lawing Road. The Battle of Ramsour’s Mill State Highway Marker is on Paul Lawing Road. Farther along Paul Lawing is the intersection with Jeb Seagle Road. A left turn on Jeb Seagle leads to some log structures and the graves of some of the participants in the battle. The site is owned by the Lincoln Country Historical Association. Google Maps search - Jeb Seagle Dr, Lincolnton, NC 28092
Wilmington is on the coast near the border with South Carolina and serves as the jumping off point to Brunswick Town State Historic Site, the ruins of a town burned by the British in 1776. To reach Brunswick Town, head west on US 17 from Wilmington, then turn left on North Carolina 133 -- Southeast River Road. Head south on River Road until Southeast Orton Road. Turn left and proceed on Orton to Brunswick Town, which is on a wooded site near the Cape Fear River. It includes a visitors' center, the ruins of the Revolutionary-era town and Civil War era earthworks. Google Maps search - 8884 St Phillips Rd SE Winnabow, NC 28479
North of Wilmington is Moores Creek National Battlefield. Moores Creek was one of the first battles in the South of the Revolutionary War and the first Patriot victory of the war. On February 27, 1776, 1,600 British troops were unaware of what they would encounter as they charged across a partially dismantled Moores Creek Bridge. Just beyond the bridge, 1,000 North Carolina Patriots waited quietly with cannons and muskets to defeat the British. This battle was the end of British rule over North Carolina. Google maps search - 40 Patriots Hall Dr, Currie, NC 28435


This sample demonstrates how AngularJS directives are used to instantiate igHierarchicalGrid.
Explore the Code


13 March 2003
Disease Outbreak Reported
As of 9 March 2003, the Ministry of Health, Niger has reported a total of 2 056 cases, including 195 deaths in the country since the outbreak began in February 2003. Of the 42 districts in Niger, 3 districts have reached the epidemic threshold: Magaria, Aguié and Matameye, and 4 districts are in the alert phase: Madarounfa, Madaoua, Tahoua and Mirriah. Laboratory tests from samples in these districts confirm Neisseria meningitidis serogroup A.
A mass vaccination campaign is on-going with the support of Médecins sans Frontières. The International Federation of the Red Cross is providing 250 000 doses of vaccine.


(:unac)
temporarily inaccessible
(:unal)
unallowed, suppressed intentionally
(:unap)
not applicable, makes no sense
(:unas)
value unassigned (e.g., Untitled)
(:unav)
value unavailable, possibly unknown
(:unkn)
known to be unknown (e.g., Anonymous, Inconnue)
(:none)
never had a value, never will
(:null)
explicitly and meaningfully empty
(:tba)
to be assigned or announced later
(:etal)
too numerous to list (et alia)


Preview
This page requires flash
click here to download
0s
Notifications
Recording
Video Id
Record
Stop
Init
Playback
Start
Pause
Seek (0s)
Seek (5s)
Server Url
Reload


Part of the {{ team.regionKey }} Region
Rookie Year: {{ team.rookieYear }}
Last Active Year: 20{{ team.lastActive.substring(0, 2) }}
Website: {{ beautifulURL(team.website) }}
Robot Name: {{ team.robotName }}
{{ team.awards.length }} awards in {{ thisSeason.description }}
Qual Rank #{{ event.rankings[0].rank }} with a record of {{ event.rankings[0].wins }}-{{ event.rankings[0].losses }}-{{ event.rankings[0].ties }}
{{event.awards.length }} Awards:


Find each clue in sequence
there are 19 clues in total
all remaining clues are found with each egg
Your starter clue is ...
You'll be wise to look here
good hunting!
via GIPHY


--- title: Every day I meet people who have so much to give but have been bullied enough or frightened enough to hold it back. It’s time to stop complying with the system and draw your own map.  Only you can do it, and you must. date: '2010-01-23T13:28:00+05:30' tags: [] tumblr_url: https://sureshshanmugam.com/post/348707306/every-day-i-meet-people-who-have-so-much-to-give ---
Every day I meet people who have so much to give but have been bullied enough or frightened enough to hold it back. It’s time to stop complying with the system and draw your own map.  Only you can do it, and you must.—Seth Godin


Follow these steps to open support tickets:
- Log in to the Algorithm Lab.
- In the left navigation bar, click Support
- On the Support page, enter a subject and message.
- If you want to attach a live deployment or backtest to the support ticket, follow these steps:
- Click Add Project, select a project, and then click OK.
- (Optional) Click Add Live Deployment, select a live deployment, and then click OK.
- (Optional) Click Add Backtest, select a backtest, and then click OK.
- Click the By submitting this request, I give QuantConnect Support Staff permission to view my project check box.
- Click Send.
"Support Ticket Created Successfully" displays.


The Orange Alliance is a site to centeralize FIRST Tech Challenge Scores so that all Teams may get access to data.
The Orange Alliance was inspired by The Blue Alliance, but we are not affiliated.
Alex is the Orange Alliance Project Manager, Lead FIRST Technical Advisor for FIRST in Michigan for both FIRST Robotics Competiton and FIRST Tech Challenge. On the TOA app Alex concentrates on Database Architecture, Data storage and Data import. He is also one of the Developers for FTC's Official Scoring System. Alex is the Owner of his own IT Consulting Firm, Fera Group, LLC, based in Northern Michigan and is 10 year volunteer with FIRST.
Kyle Flynn is the lead developer for The Orange Alliance. He develops and maintains the core functionality of The Orange Alliance as well as the public API. Spending 4 years as a student on an FRC team, Kyle is now a 2nd year FIRST in Michigan volunteer as both a FIRST Technical Advisor for FTC, and a FIRST Technical Advisor Assistant/Control System Advisor for FRC. Kyle is also studying Computer Science and Business Administration at Grand Valley State University.
Soren Zaiser Lorem ipsum dolor sit amet, consectetur adipiscing elit, sed do eiusmod tempor incididunt ut labore et dolore magna aliqua. Ut enim ad minim veniam, quis nostrud exercitation ullamco laboris nisi ut aliquip ex ea commodo consequat.
Austin Vecchio Lorem ipsum dolor sit amet, consectetur adipiscing elit, sed do eiusmod tempor incididunt ut labore et dolore magna aliqua. Ut enim ad minim veniam, quis nostrud exercitation ullamco laboris nisi ut aliquip ex ea commodo consequat.
Sean Messenger Lorem ipsum dolor sit amet, consectetur adipiscing elit, sed do eiusmod tempor incididunt ut labore et dolore magna aliqua. Ut enim ad minim veniam, quis nostrud exercitation ullamco laboris nisi ut aliquip ex ea commodo consequat.