Case

When it comes to computer cases, i.e. the thing that holds everything together, in my opinion there are only two important considerations. The first is cooling capacity, and the second is looks, in that order.

With those considerations in mind, I went with a case that’s a few years old now: the ThermalTake Core x9.

Cooling capacity:

• 4x480mm radiators
• Multiple smaller sized radiators

Looks:

• Cube

This case has more cooling capacity than I need with my current build and I really like the cube case look as it fits in my room rather well.

I made one modification to the case which I think is essential… wheels! The case itself is 40 lbs without any parts. With parts it can easily double, and then with water cooling (which is what I will be using), it’ll be much too heavy for me to move.

I picked up the wheels and the screws from my local hardware store, Rona.

Wheel details:

• 1“x1” mounting plate screws perfectly onto the holes in the case

Mounting hardware details:

• 6-32x1/2 (can use shorter screws) screws
• 6-32 hex screw nuts

Now the case can be easily moved!

Cooling

Cooling is in my opinion a critical part of building a computer and a decent budget should be allocated here. I chose to do a full custom watercooling loop capable of dissipating my estimated 800w of heat coming out of my components.

In terms of watercooling components, here are the major ones that I went with:

Radiators:

• 2x 480mm long, 45mm deep Alphacool radiators

Water blocks:

• Watercool Heatkiller IV Pro TR4 CPU water block
• EKWB EK-FC Titan V water block

Reservoir:

• EKWB EK-DBay reservoir

Water pump:

• D5 Vario 8-24V Pump with a tachometer (MCP655)

Fans:

• 12x Gentle Typhoon Performance Radiator Fans (550-1850 rpm) 58cfm

Misc:

• PWM Fan splitters
• Thermal Grizzly Hydronaut thermal paste

I ordered all my parts from https://www.dazmode.com/ and it came out to about $1,400 CAD. The one thing that I did forget is to add a water temperature sensor. Knowing water temperatures can help determine if the heat is being transferred to the cooling system optimally.

Some more cooling pictures:

CPU

At this point in time, there’s no real debate as to which CPU to use… it’s AMD Ryzen 3000 series. With AMD Ryzen 3000 there is one choice to make: a mainstream desktop CPU or the high-end desktop CPU. This is a budget/performance trade off. I chose the high-end desktop Threadripper CPU as I was coming from a HEDT Intel processor that I built in 2010.

AMD Threadripper 3960x - 24 cores/ 48 threads @ 4.2 GHz all-core / 4.5 GHz single-core:

RAM

When it comes to RAM there are two considerations: speed and amount. AMD recommends a 1600 MHz (PC3200) DDR4 speed as benchmarks show that speeds lower than 1600 MHz are significantly slower. The amount of RAM will depend on your data sizes. I would recommend a minimum of 64 GB but you may be able to get away with only 32 GB. Another heuristic to consider is the amount of RAM per CPU core as a metric for multi-processing workloads. Aim for at least 2 GB per CPU core.

I used the G.Skill Ripjaws V Series 64 GB (4 x 16 GB) DDR4-3200 Memory. Since my motherboard has 8 RAM slots, this allows me to add additional RAM in the future if necessary.

Storage

There isn’t too much to consider here, choose the fastest and largest storage solution for your budget. That means at a minimum a NVME PCI Express 3.0 solution.

I chose the ADATA XPG SX8200 Pro 1 TB M.2-2280 NVME Solid State Drive.

For data that won’t be accessed frequently I would recommend an external solution using spinning disks as a more practical and budget friendly option. I run a QNAP 4 bay NAS housing 4x 3TB Western Digital Red drives in a RAID 5 configuration.

GPU

For data science, and specifically deep learning tasks, there’s only one company to choose from, and that’s Nvidia. All of the deep learning frameworks (e.g. TensorFlow, PyTorch) are compiled with CUDA for GPU acceleration and CUDA only works on Nvidia. Choose the card with the most amount of RAM as that will most likely be your limitation.

Currently the card with the most amount of RAM but still is somewhat priced reasonably is the Nvidia Titan RTX 24 GB.

I bought my card before the Titan RTX came out, and so am using a Nvidia Titan V:

Power Supply

For power supplies, there are two schools of thought. Purchase enough power supply to cover your power needs or purchase twice as much power supply to cover your power needs. The first one is most likely cheaper. The second is a little bit more efficient, and allows for future component additions.

The first step here is to calculate your power needs. Don’t do what I did initially and just roughly estimate it in my head. There are some really great online tools to help calculate your power needs. I used this one: https://outervision.com/power-supply-calculator.

I went with getting a 1600w power supply from EVGA. My original choice was the 1000w Corsair power supply but my power needs at load was around 975w which was too close to the limit for my comfort.

The Complete Build

Here’s the complete build:

On a DS Task

I developed a package for R to read and extract data from scanned email images (yes… I realize the absurdity of dealing with scanned in emails, but I’m in law enforcement and there are considerable lengths that some folks go to maliciously comply with some of our asks). The package itself utilizes multi-core processing and is capable of operating on each file independently.

Here’s the computer reading a whole bunch of my own personal test emails:

Updates

1. Dynamic number of sentences - autoSmry now attempts to find a more appropriate number of sentences for longer texts (previously defaulted to max of 5)

This will hopefully work better for longer texts.

2. I added additional support for other languages: Russian & Chinese now added

Interactive Exploration

Observations

There are some distinct clusters of topics within the hearing texts. Most notably, there’s a rather large cluster of sexual misconduct. There are a number of additional clusters representing various types of abuse and frequency of misconduct as well.

One additional observation I noticed was that males greatly outnumber females.

Appendix

Updates

1. You may now just enter a URL into the textbox and autoSmry will read that entire page instead of requiring you to copy & paste a webpage’s contents into the textbox (URL must point to a html file).

To all the people who suggested adding the ability to parse the URL directly… this made a huge improvement on ease of use (for me at least). Thanks for the suggestion!

The original limitations still apply however. If the webpage is too long, it will timeout.

Also, while it tries to only read the main content, it does sometimes screw it up. You can check for any odd shapes in “Sentence Relationships”, as any odd shapes will likely indicate that it has unrelated text in there somewhere. The odd shapes may affect the quality of the summary. (Odd shapes to me are anything that resembles a scary insect…). The algorithm is robust enough to recognize and ignore completely unrelated sentences, but if there are a lot of them, it may start incorporating it.

2. I added additional support for other languages.

This one is still experimental in my mind. What I did was apply the same sort of preprocessing that I did for the English version (minus some English-specific ones) to a few more languages. This should theoretically result in much better sentence choices than before.

Testing this however is extremely labourious for me since I only know English. I would appreciate any feedback on how it’s working for the following languages:

• French
• German
• Spanish

If the results aren’t terrible… I’ll look into adding additional language support.

Tl;dr

1. Enter a URL directly; no more copy/pasting from a webpage
2. Too long; didn’t read = trop long; n’a pas lu = zu lang; habe nicht gelesen = demasiado largo; no leí

Demo of updates

Articles tested in the video demo:

1. PCs dismiss Ontario’s Chief Scientist
2. The heat wave continues to claim victims in Quebec (French)

Dataset

We’ll reuse the sunspots dataset since it’s one of the better ones (it’s long and exhibits nice seasonal patterns).

And this is the testing data which we will test our models against:

Dense layers

First up is the dense network. I’m going to skip showing the code for this here since I showed it in my last post.

Here are the model details:

## Model
## ___________________________________________________________________________
## Layer (type)                     Output Shape                  Param #     
## ===========================================================================
## dense_1 (Dense)                  (1, 256)                      37120       
## ___________________________________________________________________________
## dense_2 (Dense)                  (1, 128)                      32896       
## ___________________________________________________________________________
## dense_3 (Dense)                  (1, 32)                       4128        
## ___________________________________________________________________________
## dense_4 (Dense)                  (1, 1)                        33          
## ===========================================================================
## Total params: 74,177
## Trainable params: 74,177
## Non-trainable params: 0
## ___________________________________________________________________________

GRU

Step 1 - we need to slightly tweak the data for GRU models since GRU expects a 3D tensor, instead of the 2D tensor used in the prior model.

Step 2 - we can now construct a GRU model:

# Model params
units <- 4
inputs <- 1

# Create model
model.GRU <- keras_model_sequential()

model.GRU %>%
        layer_cudnn_gru(units = units,
                         input_shape = c(lookback, 1),
                         batch_size = inputs,
                         stateful = T,
                         return_sequences = T
                         ) %>%
        layer_dropout(0.2) %>%
        layer_cudnn_gru(units = units/2,
                        stateful = T,
                        return_sequences = T) %>%
        layer_cudnn_gru(units = 1,
                        stateful = T) %>%
        layer_dropout(0.2) %>%
        layer_dense(units = 1)

# Compile model
model.GRU %>% compile(optimizer = "rmsprop",
                  loss = "mean_squared_error",
                  metrics = "mae")

Step 3 - we can now attempt to train the model:

## Model
## ___________________________________________________________________________
## Layer (type)                     Output Shape                  Param #     
## ===========================================================================
## cu_dnngru_1 (CuDNNGRU)           (1, 144, 4)                   84          
## ___________________________________________________________________________
## dropout_1 (Dropout)              (1, 144, 4)                   0           
## ___________________________________________________________________________
## cu_dnngru_2 (CuDNNGRU)           (1, 144, 2)                   48          
## ___________________________________________________________________________
## cu_dnngru_3 (CuDNNGRU)           (1, 1)                        15          
## ___________________________________________________________________________
## dropout_2 (Dropout)              (1, 1)                        0           
## ___________________________________________________________________________
## dense_5 (Dense)                  (1, 1)                        2           
## ===========================================================================
## Total params: 149
## Trainable params: 149
## Non-trainable params: 0
## ___________________________________________________________________________

Step 4 - we can now make predictions from the model:

## Predict based on last observed sunspot number
predictions.GRU <- numeric() #vector to hold predictions.GRU

# Generate predictions.GRU, starting with last observed sunspot number and feeding
# new predictions.GRU back into itself
for(i in 1:n){
    pred.y.GRU <- x.GRU[(nrow(x.GRU) - inputs + 1):nrow(x.GRU), 1:lookback, 1]
    dim(pred.y.GRU) <- c(inputs, lookback, 1)
    
    # forecast
    fcst.y.GRU <- model.GRU %>% predict(pred.y.GRU, batch_size = inputs)
    fcst.y.GRU <- as_tibble(fcst.y.GRU)
    names(fcst.y.GRU) <- "x"
    
    # Add to previous dataset data.tibble.rec
    data.tibble.rec.GRU <- rbind(data.tibble.rec.GRU, fcst.y.GRU)
    
    ## Recalc lag matrix.GRU
    # Setup a lagged matrix.GRU (using helper function from nnfor)
    data.tibble.rec.lag <- nnfor::lagmatrix(data.tibble.rec.GRU$x, 0:lookback)
    colnames(data.tibble.rec.lag) <- paste0("x-", 0:lookback)
    data.tibble.rec.lag <- as_tibble(data.tibble.rec.lag) %>%
    filter(!is.na(.[, ncol(.)])) %>%
    as.matrix()
    
    # x.GRU is input (lag), y.GRU is output, multiple inputs
    x.GRU <- data.tibble.rec.lag[, 2:(lookback + 1)]
    dim(x.GRU) <- c(nrow(x.GRU), ncol(x.GRU), 1)
    
    y.GRU <- data.tibble.rec.lag[, 1]
    dim(y.GRU) <- length(y.GRU)
    
    # Invert recipes
    fcst.y.GRU <- fcst.y.GRU * (range.max.step - range.min.step) + range.min.step
    
    # save prediction
    predictions.GRU[i] <- fcst.y.GRU %>% 
            InvBoxCox(l)
    predictions.GRU <- unlist(predictions.GRU)
}

Results!

Ok let’s see some results! (Since we have 2 models, I’m also going to sneak in an ensemble model which is simply an average of the dense and GRU model predictions).