FoxCon Toledo 2018 Schedule

FoxCon Toledo 2018

Conference Presentation Schedule

Park Inn Hotel, Toledo, Ohio

January 27th & 28th, 2018

Saturday January 27

Time    Speaker         Topic

08:00-09:00 Bob Ruple       Opening Comments

1 09:00-10:15 Bob Pierce     Living in a Legacy World

10:15-10:30                Break

2 10:30-11:45 Doug Hennig     Practical Uses of wwDotNetBridge to Extend Your VFP Applications

11:45-12:45 pm              Lunch at Park Inn Hotel

3 12:45-02:00 Sam Nasr        Data Time Travel with Temporal Tables

02:00-02:15                 Break

4 02:15-03:15 David Johnson   Using Big Data from Automotive Assembly Errors

03:15-03:30                Break

5 03:30-04:45 Dave Bernard    Lessons Learned from 40 Years of Software Development

Sunday January 28

Time      Speaker        Topic

08:30-09:00 Bob Ruple       Opening Comments

6 09:00-10:15 Ondrej Balas   Open Source Game Development in the .NET Ecosystem

10:15-10:30                Break

7 10:30-11:45 Kevin Cully        Accessing and manipulating application data using Xojo

    11:45-12:45 pm              Lunch at Park Inn Hotel

8 12:45-01:15 Mike Levy       Given I have to test, when I do, then it should be cool

01:15-01:30                Break

9 01:30-02:45 Mark Beno       CLEARPATH The OMOP Common Data Model

02:45-03:00                Closing Comments

3:00 pm                                       Conference Dismisses

Codemash 2018 reviews

I’m writing my thoughts here about the sessions I attended at CodeMash 2018. Overall, I had a great time and learned some new and important things about the latest technologies. This year I tried to attend more data science / machine learning talks, though several of them were cancelled at the last minute. (Perhaps the bad weather was to blame.)

I wrote these notes during or immediately after each talk, and I submitted some of the text to the session survey part of the Attendee Hub app on my phone. I think it’s a good idea to send the feedback to the speakers, but I don’t think it is used by reviewers for next year, so I’m not sure it matters very much. Regardless, I write to consolidate my own learning, if for no other reason.

Fast Neural Networks – a no brainer

Speakers: Riccardo Terrell

The speaker used the agent model because ANNs are embarassingly parallel. Map agents to nodes – 1:1, send updates between them (values forward, backpropagation corrections backward). Make agents reactive to messages (updates from dependent nodes). The speaker has an e-book on MEAP about it – Parallel NN as map reduce problem – simpler way to implement NN.

The speaker tried to cover too much content. Also, I didn’t hear any good outcomes or reasons for why he reimplemented backpropagation (a very old algorithm). What was learned by redoing it with actors?

Getting Started with Deep Learning

Speakers: Seth Juarez

confusion matrix- be careful of TN vs FP box location. Works for MS; uses VS to edit Python; tensorflow implementation in python for MNIST. Check channel 9 msdn for newer presentation

cool twilio use – text the presenter to ask questions during presentation

This speaker was great because he told lots of jokes to keep the talk interesting despite the underlying math. I really liked the twilio based questions via text messages!

Imposter Syndrome: Overcoming Self-Doubt in Success

Speakers: Heather Downing

The speaker did a very good job motivating the subject, but I would’ve liked to hear more about practical things that can be done to deal with imposter syndrome. I agree with “co-bragging”, but I think other good options include public speaking to build confidence or doing volunteer work to appreciate how it’s a 1st world problem.

cycle of failure: overly confident – procrastinate and rely on luck. under confident – put in excessive time and effort. Discount success and undermine ego.

How can you tell if someone will eventually succeed after a failure? You are not the failure; own your mistakes and learn from them. Don’t be scared of failure; be scared of not finding the truth.

“Co-bragging” – praise your co-workers’ acheivements, and they praise you. Create a positive culture that avoids hurtful comparisons.

Fake it until you become it, then pay it forward.

Machine Learning at Scale, How to Keep Learning as Your Data Keeps Increasing

Speakers: Matt Winkler

This was exactly why I come to codemash – I want to hear about the latest tech so that I can keep up with the industry standards. I thought the speaker did an excellent job of reviewing the latest ML implementations and describing how to deploy them at scale. I loved all the detailed examples!

data prep: spark, pandas, dplyR
scale up: spark cluster, HDInsight
aggregation: AML workbench

Azure Machine Learning workbench can automatically learn how to create columns by example (formatting and aggregating a date time column). (automatically generates python code!)

Nvidia’s latest GPU was announced at NIPS conference (academic AI researchers).

VM recommendations: use version control so that you can migrate easily. make scripts for any required setup. track your outcomes from experimenting with different models. benchmark the price effectiveness of different configurations.

home camera – Amazon deep lens – recognizes faces

MSSQL 2017 has integrated ML algorithms INSIDE it! see tutorials?!

Walking the High Wire: Patching Erlang Live

Speakers: John Daily

The speaker did a great job of motivating the use of Erlang for live patches, which is exactly what I wanted to hear about. But I would’ve liked to have seen a non-trivial example, or some more information about how it’s used in the real world.

Power isn’t pretty – erlang is designed for fault tolerance, not usability. Its network IO is fundamentally async but reliable, unlike RPC or CORBRA.

App architecture without RDBS vs NoSQL drama

Speakers: Jeff Putz

The speaker has a lot of good experience to share. He’s obviously worked in diverse applications, and I appreciate hearing about tradeoffs between technologies instead of just advertising the latest tech. I think it’s really important to repeat the message about not being obsessed with the latest tech just because it’s new. I wish the presentation didn’t get sidetracked by arguments about issues of personal preference in DB design.

NoSQL advantages – less CPU, high write thruput, maybe higher dev productivity

Fight the urge to normalize everything. Don’t make complicated schema for queries that will never be used. Focus on the problem domain, not the persistence and code style. Running multiple queries can be OK (as compared to a join).

SQL can do key value pairs OK. The death of SQL in 2010 was greatly exaggerated.

Aggregate queries with joins cause lots of database work. Avoid redoing them in real time. Use the client layer to maintain a cached state of frequently queried aggregates; don’t be afraid to store redundant data because it’s so cheap now. SQL was originally designed to minimize storage at the expense of CPU (i.e. normalization).

Scala for the Java Developer: It’s Easier Than You Think

Speakers: Justin Pihony

I liked this talk because I want to learn at least one new programming paradigm every time I come to CodeMash, and the speaker did a great job of being an ambassador for Scala. I appreciated hearing about the limitations and realistic expectations for the language. Things to improve: show applications and companies using it.

Scala runs on JVM; compatible with java, but it’s functional and immutable first. Less verbose; fixes many annoyances with Java’s legacy conventions. Includes REPL.

Ride the rails: Handling errors the functional way

Speakers: Sam Hanes

The speaker did a very good talk on functional programming basics in F#. I enjoy sessions like these for reminding me that there are alternatives to traditional imperative paradigms. Suggestion: use font colors with better contrast (dark red text on black backgrounds is difficult to read). Overall very good talk.

Functional programming – avoid mutable state.

Use bind to connect a switch function to two track handling. Exceptions can be converted into failures (if they are predictable enough to catch).

A Game of Theories: why languages do what they do

Speakers: Rae Krantz

The speaker did a fun talk about comparing programming languages and GoT. This type of talk is nice to have as a break in between “serious business” and learning new tech. Suggestions: use the full time slot. Show the same algorithm implemented in different languages. Talk more about the supporting libraries (not just the language itself).

Ruby, python, go, erlang, clojure, JavaScript – not sure why these 6 as opposed to any other survey of languages. Popularity?

(I went to this talk because the session “The Polyglot Data Scientist – Adventures with R, Python, and SQL” by Sarah Dutkiewicz was cancelled. It sounded like the snow storm scared a lot of people into leaving CodeMash early, and some other speakers cancelled their talks for being sick.)

Image Recognition with Convolutional Neural Networks using Keras and CoreML

Speakers: Tim LeMaster

This talk was too introductory, barely covering any applications and only talking about history. I walked out after 10 minutes to go eat lunch and do professional networking.

How to Count Your Chickens After They’ve Hatched

Speakers: Gary Short

The speaker is very entertaining and amusing, and it’s great to see a fun talk about a relevant topic (ML). Images are easy to relate to, and it’d be cool to see more talks with them. I don’t think C# was the right choice for this algorithm – python sklearn has built-in implementations for this problem.

Counting chickens in brightfield images – threshold grayscale image, then try k-NN. k-NN doesn’t work because k is unknown? The algorithm is pretty ad hoc, but more power to him if it works. 85% accurate but told to deploy it by customer farmer anyway.

[Sponsor Session] Attracting and Retaining Top Technical Talent (a.k.a. “Insomnia Cure #1 for Software Development Leaders”)

Speakers: Stout Systems

This talk was pretty good, and it make me feel better about my chances of getting a different job someday. On a daily basis, I really have no idea how good the market is for programmers, but I still remember the 2004 IT recession.

top 5 for recruiting/retaining talent –

5. salary (and PTO, retirement, health care, bonus, stock, options – cash equivalents)

4. workplace culture (office space features, remote work, flex schedule, work/life balance)

3. career growth (holding same job for years is boring and a career killer; upskilling and training is good. )

2. [lack of] process (shifting requirements, changing priorities, inconsistent deadlines, no deployments) – also leadership issues (excessive meetings, no clear decisions).

1. technology stack (fear of extinction; huge, messy codebase) – transform or evolve, within appropriate constraints (relevant tech, reasonable schedules). automate mundane tasks (build, deploy). allow some freedom of tools (svn vs git, OS, editors).

R Performance (It’s not R, it’s You)

Speakers: Tim Hoolihan

The speaker gave a pretty good overview of performance issues in R. I’m not really an R user, so I attended this talk just to see if it was much better or different than python based ML. My conclusion: no because R uses the python ML libraries!

How Not to Destroy Data

Speakers: Michael Perry

I liked how this talk summarized an academic topic in a relatable way. Despite being in the last time slot, I learned some fascinating ideas about Historical Modelling. I like having some more challenging topics to attend.

Audit log problems – not reliable or type safe. Large. Simple

Event sourcing. Derive object state by reading whole table of changes. Order is significant.

Historical modelling. Partially ordered. Not simple, but better??

* Every field is immutable
* Surrogate key is only used internally (not in API)
* everything else is the identity in API

Use timestamps as “uniquifiers”

* A fact cannot be deleted
* query uses WHERE NOT EXISTS subclause

speaker name precedessor record – a Name is identified by its nameId and all predecessor records. This is git-style version control inside a db!

Mutable properties can’t be part of entity. detect and resolve conflicts via knowing predecessors.

Events move entities forward thru workflow, pointing backward to previous event.

Advantages: no locks. Offline data is OK. Cluster synch is easier (eventual consistency via Active-Active clusters). Microservice as historical db.

 

Presentations List

Here is a list of work I’ve presented since 2015 at various local users groups and conferences. These projects show a commitment to continued professional development and networking. I’ll keep updating this list as time goes by.

2018

FoxCon Toledo 2018 Presentation – Big Data from Automotive Assembly Errors (TBD: Jan 27, 2018 ?).

CodeMash 2018 Lightning talk (TBD) – Fast comparison of Tesseract and a Convolutional Recurrent Neural Network for automatically reading dot peened VIN stamps.

2017

Google Developers Group Toledo and Toledo Web Professionals meetings on Nov 9, 2017 – Building Your Own Collaborative Editing Web Forms For Free.

FoxCon Toledo 2017 Presentation – Using Machine Learning to Automatically Predict and Identify Defects in Automotive Assembly Processes

Northwest Ohio SQL PASS Chapter presentation – Using Columnstore Indexes to Store and Analyze Billions of Torques. Cancelled because users group has been abandoned!

2016

Toledo Web Professionals 2016 Presentation: Real-time Messaging to Webapps from a Production Database

FoxCon Toledo 2016 Presentation – Building Webapps to Help You Build a Jeep (video references here).

2015

FoxCon Toledo 2015 Presentation – SQL Server Notifications in a manufacturing environment. Also presented at the NWNUG meeting in Feb 2015 and again at the FANUG meeting shortly after.

Northwest Ohio SQL PASS Chapter Presentation – an edited version of SQL Server Notifications in a manufacturing environment with less C# and more SQL Server details about database administration for Service Broker.

Presentation – Building Your Own Collaborative Editing Web Forms For Free

Links to slides: Google SlidesPDF format, PPT format

Presented at Google Developers Group Toledo and Toledo Web Professionals meetings on Nov 9, 2017.

Abstract

Have your business users ever said, “we have this Excel form that we need to turn into a web form”? So you, as a full-stack web developer, turn it into a HTML form with an AJAX POST to save the data to a database table in the standard CRUD model. It works well enough, but then the users said, “we really need simultaneous editing for everyone in the office.” Now you’re in trouble because you’re trying to reinvent Google Docs / Sheets, which are very complex. How do those collaborative editing tools really work?

We will look at the Google Realtime API, which uses Operational Transformation to automatically synchronize a document between multiple simultaneous editors. Everything you know about distributed version control systems applies to this situation, but now you need to make it work seamlessly for users who have never heard of “git rebase”. The client and server implementation of Operational Transformation is very challenging.

Alternatives to Operational Transformation (OT) include Differential Synchronization (DS, aka. 3-way merge), Conflict-free Replicated Data Type (CRDT), and plain old Last Write Wins (LWW). For any of these methods, the critical elements include websockets, message queues, and persistent data storage. This presentation will include a demonstration of a simple implementation of collaborative editing with free, locally hosted software only.

 

Presentation idea – Using Columnstore Indexes to Store and Analyze Billions of Torques

This is an abstract I wrote for a local area users group, only to find out that they had stopped meeting. Toledo doesn’t seem to be able to keep many computer-based user interest groups alive. I’m posting it here for my own records.
Abstract
Torque tools (impact wrenches, electronic motors, rotary torque sensors) produce lots of data as a vehicle is being built. Torque data is used to control the movement of the production lines and to do quality control analysis. During production, traditional row-based storage makes the most sense, using the VIN and torque tool ID as the primary key in a table optimized for insertion speed and VIN-based lookups. However, post-production it makes more sense to switch to column-based storage for quality control analysis because aggregation functions (mean, std. dev.) need to be computed over large ranges of data (regardless of VIN), and many torque values are similar. Columnstore indexes are a good solution to the latter storage and analysis problem, and they have gotten much better in SQL Server 2016. I’ll describe how they’re useful for this problem for analyzing how well the torque tools are working using simple statistical techniques.

Thoughts on Project Euler in Python

I’ve been doing Project Euler problems to learn more about Python 3.5+ (as opposed to 2.7). The Project Euler website says, “Real learning is an active process and seeing how it is done is a long way from experiencing that epiphany of discovery. Please do not deny others what you have so richly valued yourself.” So I’m not supposed to post full solutions or even hints. However, I can make general comments that are not specific to any Project Euler problems.

I find it very helpful to have the following tools ready to go before doing any Project Euler problems: a list of primes up to 10**9 or so, a list of primitive Pythagorean triplets up to 10**6, and the latest version of a big integer library. Much of Project Euler is based on prime numbers, so I used primegen to create a text file with lots of primes in it. Reimplementing the Sieve of Eratosthenes gets really boring after a while, and the Sieve of Atkin is much better anyway.

Pythagorean triplets show up occasionally, so I have a static text file with primitive triplets up to 10**6. I used an existing pythagorean triplets generator, but the matrix formula isn’t too terrible to implement.

Python 3 has much improved support arbitrary length integers over Python 2. The int datatype is gone, replaced by long, then unified back to int again. The only real problem is remembering the change in the integer division operator, but I’ve used “from future import __division__” practically everywhere.

Generators and comprehensions have big improvements in Python 3+. I really like them for using a functional programming style, and they can improve program speed and reduce memory usage a bit.

Finally, regardless of language, I always try to review some common strategies from dynamic programming and graph search algorithms. It’s surprising how often these ideas are part of the best solutions to Project Euler problems.

Linear algebra review

It’s been a while since I tried to solve a system of equations without
using a numerical library, so I figured it was time to do a linear
algebra review.

\[
A=\left[\begin{array}{cc}
1 & 2\\
3 & 4
\end{array}\right]=\left[\begin{array}{c}
r_{1}^{T}\\
r_{2}^{T}
\end{array}\right]=\left[\begin{array}{cc}
c_{1} & c_{2}\end{array}\right]
\]

This should be the easiest matrix to work with: small size, nice integer values, non-colinear columns and rows, non-zero determinant, full rank, etc. Let’s go through the basic definitions, just because it’s been a while. $A$ is 2×2 (MxN), which is small and square. Let’s check the column space of $A$ for colinearity by reducing to row echelon form by adding $-3r_{1}^{T}$ to row 2:

\[
\left[\begin{array}{cc}
1 & 2\\
0 & -2
\end{array}\right]
\]

Then adding $r_{2}^{T}$ to row 1:

\[
\left[\begin{array}{cc}
1 & 0\\
0 & -2
\end{array}\right]
\]

So the good news is that the column space of $A$ has linearly independent columns, $\left[\begin{array}{c}
1\\
3
\end{array}\right]$ and $\left[\begin{array}{c}
2\\
4
\end{array}\right]$, which form a basis for $\mathbb{R^{\mathrm{2}}}$, and rank($A$) is 2. So the null space of $A$ is empty. That’s the best possible outcome for a matrix because it means that an inverse exists.

But before exploring that, let’s think about the row space of $A$. Using the same row reductions as above, we can conclude that $A$ has linearly independent rows, $\left[\begin{array}{cc} 1 & 2\end{array}\right]$ and $\left[\begin{array}{cc} 3 & 4\end{array}\right]$, which form a basis for $\mathbb{R^{\mathrm{2}}}$, and rank($A^{T}$) is 2. So the left null space of $A$ is also empty. The row space of $A$ is isomorphic to the column space of $A^{T}$ by definition, and $A$ happens to have full rank, so an inverse exists. Let’s use Gauss-Jordan elimination to find it:

\[
\left[\begin{array}{ccccc}
1 & 2 & | & 1 & 0\\
3 & 4 & | & 0 & 1
\end{array}\right]
\]

Starting with an augmented matrix $\left[\begin{array}{ccc}
A & | & I\end{array}\right]$, we can use row operations to find $\left[\begin{array}{ccc}
I & | & A^{-1}\end{array}\right]$. Add $-3r_{1}^{T}$ to row 2:

\[
\left[\begin{array}{ccccc}
1 & 2 & | & 1 & 0\\
0 & -2 & | & -3 & 1
\end{array}\right]
\]

Then add $r_{2}^{T}$ to row 1:

\[
\left[\begin{array}{ccccc}
1 & 0 & | & -2 & 1\\
0 & 2 & | & -3 & 1
\end{array}\right]
\]

Finally rescale row 2:

\[
\left[\begin{array}{ccccc}
1 & 0 & | & -2 & 1\\
0 & 1 & | & -\frac{3}{2} & \frac{1}{2}
\end{array}\right]
\]

Therefore:

\[
A^{-1}=\left[\begin{array}{cc}
-2 & 1\\
-\frac{3}{2} & \frac{1}{2}
\end{array}\right]
\]

Now we need to check that $A^{-1}A=I$:
\begin{eqnarray*}
\left[\begin{array}{cc}
2 & 1\\
-\frac{3}{2} & \frac{1}{2}
\end{array}\right]\left[\begin{array}{cc}
1 & 2\\
3 & 4
\end{array}\right] & = & \left[\begin{array}{cc}
1 & 0\\
0 & 1
\end{array}\right]
\end{eqnarray*}

Of course, there is an explicit formula for the inverse of a 2×2 matrix:

\[
\left[\begin{array}{cc}
a & b\\
c & d
\end{array}\right]^{-1}=\frac{1}{\det A}\left[\begin{array}{cc}
d & -b\\
-c & a
\end{array}\right]
\]

For our $A$, $\det A=ad-bc=-2$. Unfortunately, analytical inverses don’t exist for larger matrices, or they are so long and complex as to be of limited utility. But there is at least one important idea to take away from the inverse: it can only exist if the determinant is non-zero. This becomes a very important fact for the eigenvalue problem.

One last thing I wanted to write about for now: the L2 norm (or Euclidean norm) of a vector $x=\left[\begin{array}{cccc}
x_{1} & x_{2} & \cdots & x_{n}\end{array}\right]^{T}$ is defined as:

\[
\left\Vert x\right\Vert _{2}^{2}=\sum_{i=1}^{n}x_{i}^{2}
\]

Suppose that we’re fitting data $\left(a_{ij},y_{i}\right)$ to a known linear model$A$ and we want to determine the unknown coefficients $x$ that best fit the data using ordinary least squares:

\begin{eqnarray*}
\left[\begin{array}{c}
y_{1}\\
y_{2}\\
\vdots\\
y_{m}
\end{array}\right] & = & \left[\begin{array}{cccc}
a_{1,1} & a_{1,2} & \cdots & a_{1,n}\\
a_{2,1} & a_{2,2} & \cdots & a_{2,n}\\
\vdots & \vdots & \ddots & \vdots\\
a_{m,1} & a_{m,2} & \cdots & a_{m,n}
\end{array}\right]\left[\begin{array}{c}
x_{1}\\
x_{2}\\
\vdots\\
x_{n}
\end{array}\right]\\
y & = & Ax
\end{eqnarray*}

And we want to choose the $x$ which minimizes the L2 norm of the residuals because we assume them to be Gaussian:

\[
J\left(x\right)=\left\Vert Ax-y\right\Vert _{2}^{2}
\]

Then $J\left(x\right)$ can be expanded:

\begin{eqnarray*}
\left\Vert Ax-y\right\Vert _{2}^{2} & = & \left(Ax-y\right)^{T}\left(Ax-y\right)\\
& = & \left(x^{T}A^{T}-y^{T}\right)\left(Ax-y\right)\\
& = & x^{T}A^{T}Ax-x^{T}A^{T}y-y^{T}Ax+y^{T}y
\end{eqnarray*}

However, $x^{T}A^{T}y$ is a scalar that can be computed as $y^{T}Ax$ by reversing the order of the multiplications, so the last expression can be further simplied:

\begin{eqnarray*}
x^{T}A^{T}Ax-x^{T}A^{T}y-y^{T}Ax+y^{T}y & = & x^{T}A^{T}Ax-2y^{T}Ax+y^{T}y
\end{eqnarray*}

This might look ugly, but we can now minimize $J\left(x\right)$ by
taking the derivative with respect to $x$:

\begin{eqnarray*}
\frac{dJ\left(x\right)}{dx} & = & 2x^{T}A^{T}A-2y^{T}A\\
& = & 2A^{T}Ax-2A^{T}y
\end{eqnarray*}

Where we used the fact that $x^{T}A^{T}A=A^{T}Ax$ and $y^{T}A=A^{T}y$ because it’s just changing the order of the multiplications again.

Now we can derive the celebrated pseudo-inverse of $A$ by setting the derivative to zero:

\begin{eqnarray*}
2A^{T}Ax-2A^{T}y & = & 0\\
A^{T}Ax & = & A^{T}y\\
x & = & \left(A^{T}A\right)^{-1}A^{T}y
\end{eqnarray*}

However, the inverse of $A^{T}A$ may not exist, or it may be very hard to compute (due to numerical instability). An alternative solution is to use gradient descent. Since we already have $\frac{dJ\left(x\right)}{dx}$ in a nice form:

\begin{eqnarray*}
\frac{dJ\left(x\right)}{dx} & = & 2A^{T}\left(Ax-y\right)
\end{eqnarray*}

We can start at any point $x=x_{0}$ and take a step along the direction given by the derivative, $x_{1}=x_{0}-\gamma\frac{dJ\left(x\right)}{dx}$. The problem is how big of a step to take. Despite the existence of a global minimum and an analytical form for the derivative, the steps could either be too small (taking forever to converge) or too large (diverging even when starting near the global minimum). This is where I wrote a paper about bracketing the minimum using a priori constraints (i.e., Golden section search and Brent’s method), but variations on line search minimization are also possible.

I’ve read that the conjugate gradient method is the more popular solution to this problem now. Gradient descent searches strictly along the derivative, whereas the conjugate gradient method chooses a different search direction every time. The Grahm-Schmidt procedure is used to orthogonalize the gradient vectors, and then the conjugate gradient method moves along that new basis. This can be much faster than gradient descent, but it can become slow if the condition number of $A$ is too large. But it’s still a good choice because it doesn’t require the Hessian matrix to be calculated or inverted (as per Newton’s method).

If you’ve got lots of memory and $M,N$ are small-ish, the Levenberg-Marquardt algorithm can converge even faster because it approximates the Hessian with the Jacobian matrix and chooses directions either along the derivative or the Hessian, whichever is better. Unfortunately, it doesn’t work with regularization, and it has a few more internal parameters, and it usually runs out of memory when computing $\left(J^{T}J+\lambda I\right)^{-1}$. So I usually end up using the conjugate gradient method anyway because it can be regularized and doesn’t require crazy amounts of memory.

At CodeMash 2017 I heard a presentation about artificial neural networks where the presenter complained bitterly about how his L2 minimization (“backtracking”) in the neural network was converging very slowly. I thought to suggest an improved algorithm (conjugate gradient), but his talk was focused on a high level introduction with no math, so it didn’t seem appropriate at the time. That inspired me to write this post. Then I saw that someone else already did conjugate gradients with artificial neural networks in 1992. 😛

CodeMash 2017 Fri

Horizontally Scaling Node.js and WebSockets by James Simpson. Prepare for success with scalability. Automatic failover increases uptime. Load balancers: HAProxy, NGINX, ELB, http-proxy. HAProxy is recommended for not having vendor lock-in and for ease of deployment. Application: nodejs, running on multiple servers. Messaging: Redis, RabbitMQ, ZeroMQ. Redis can do key/value store in addition to pub/sub queues. Approaches: single core vs multi-core servers. (smaller, single core servers can scale up and down better than larger, multi-core servers. Single server failures are easier to manage when the number of servers automatically scales.)

Abusing C# More by Jon Skeet. Silly and amusing edge cases of C# 7. I’m pretty sure I will never use the mongolian vowel separator, but at least now I know that it exists.

Tune SQL Server Like a Guru – The Big Three! by Kevin Boles. The big three are File IO Stall differential analysis, Wait Stats differential analysis, and sp_whoisactive. Not a surprise to me, but it’s still good to review them so that I don’t feel like I’m missing out on some new method of figuring out where SQL Server is having problems. Mr. Boles is an excellent speaker, and it was helpful to hear his explanations of some of the wait types.

CXPACKET – excessive means inefficient parallel processing. See common TSQL Mistakes presentation (mismatched datatypes and function calls in WHERE clause). Adjust MAXDOP and cost threshold for paralelism. The default SQL Server configuration is bad. VMs can be especially bad: thin provisioned disks, underpowered CPU.

ASYNC_NETWORKIO – server-side cursors are really bad. MS Entity Framework often does this.

PAGELATCHIO – slow r/w to disk.

PAGELATCH – not related to disk. Just allocation/deallocation of pages. Only 1 thread can hold the 8 KB page at a time. See especially TempDB.

sp_WhoIsActive – best possible analysis tool. See also Ola Halagren’s maintenance tool.

SSMS tools pack – costs about $50, but automatically puts begin tran/rollback in every new query window in SSMS. Could save your job.

An Applied Introduction to R by Gary Short. Difference between trading and gambling: you can play both sides in trading, but not in gambling. Also, you can’t bet against a horse in gambling. I found some of the high frequency trading terms in this presentation to be confusing: Dutching (betting on multiple stocks simultaneously), Scalping (not ticket scalping; buy at Key prices, aka crossover points, are points at which the first derivative changes??), “Back” vs “Lay”. I didn’t get much R out of this talk.

Machine Learning for Predictive Hiring aka Recruiting Isn’t Just Rainbows and Kittens by Carmen Fontana. Speaker used to be a dev, now a recruiter at a business consulting firm. 60% FT, 40% contractors. Many short term contracts. Machine Learning with Textio – optimizes job ads for length, sentence length, wording choices, gender tone, verb usage. This was a pretty interesting talk because I didn’t know that some HR departments are getting better about not using keyword filtering for every job ad.

Machines Learning Human Biases: How Does It Happen? Can We Unteach Them? by Devney Hamilton. Google Word2Vec (2013). MIT team used Google News data to produce vectors representing the similarities between words (i.e., a word embedding). The ANN produced male/female-aligned patterns that reflect the existing stereotypes. De-bias the vector space?

FoxCon Toledo 2017 Presentation – Using Machine Learning to Automatically Predict and Identify Defects in Automotive Assembly Processes

Operators use torque tools to build a car with nuts and bolts, but what happens when the tools themselves have problems? In this presentation Dave will examine a case study of how preventative maintenance and quality inspection can be improved by using machine learning to model the failures observed on the assembly line.  Learn how Bayesian prediction (frequently used in email spam filters) can be applied to predict and identify these failures before they occur.

Presentation download: [ machinelearningdefects PDF ]

 

FoxCon Toledo 2017 Conference Presentation Schedule

Saturday January 28

Time             Speaker                  Topic

08:00-09:00 Bob Ruple           Opening Comments

1 09:00-10:15 Bob Pierce          Controlling Factory Automation with VFP – Behind the Scenes

10:15-10:30                 Break

2 10:30-11:45 Doug Hennig       Windows Powershell – Batch Files on Steroids

11:45-12:45 pm             Lunch at Park Inn Hotel

3 12:45-02:00 Mike Levy           Building Hypermedia APIs Using .NET Core

02:00-02:15                 Break

4 02:15-03:30 David Johnson    Using Machine Learning to Automatically Predict and Identify Defects in Automotive Assembly Processes

03:30-03:45                Break

5 03:45-05:00 Dave Bernard     The Death of Privacy

Sunday January 29

Time            Speaker                   Topic

09:00-09:15  Bob Ruple         Opening Comments

6 09:15-10:15  Ondrej Balas     Identity Management in ASP.NET Core

10:15-10:45                Break

7 10:45-noon   Mike Feltman    Introducing F1 MD – Just What the Doctor Ordered

Noon-1:15 pm               Lunch at Park Inn Hotel

8 01:15-02:30  Mark Beno        CLEARPATH (CLEveland Area Research Platform for Advancing Translational Healthcare)

02:30-03:00                Closing Comments

3:00 pm                Conference Dismisses