Adrian Salceanu - Julia Programming Projects: Learn Julia 1.x by building apps for data analysis, visualization, machine learning, and the web

Only one small step and we're ready to train our model. We need to convert the DataFrame into an array and to permute the dimensions of the array so that the DataFrame columns become rows. In the new structure, each column (zip code and count pair) is considered a training sample. Let's do it:

Our training data is ready! It's time to put it to good use:

We're using the k-means algorithm by invoking the function with the same name. As arguments, we provide the training_data array and give it three clusters. We want to split the areas into three tierslow, medium, and high density. The training shouldn't take more than a few seconds. And since we gave it the display=:iter argument, we get progressive debug info at each iteration. For the seeding algorithm, we have used k-means++ ( :kmpp ).

We can thus say that any value in a time series can be represented through a function of the four components we discussed earliertrend, seasonality, error, and cycle. The relationship between the four components can be either additive or multiplicative.

The additive model is used when the seasonal variation stays about the same across time. The trend may be upward or downward, but the seasonality stays more or less the same. A plot of such data will look very similar to this:

If we draw two imaginary lines between the yearly maximums and the yearly minimums, the lines will be pretty much parallel.

For an additive time series model, the four components are summed up to produce the values in the series. Thus, a time series Y can be decomposed into Y = Trend + Cycle + Seasonality + Noise.

A multiplicative model should be used with a time series where the seasonal variability increases over time. For example, a typical multiplicative time series is represented by the international airline passenger data between January 1949 and January 1960:

We can see how the variation in the seasonal pattern is correlated with the level of the time series: the more passengers we have, the higher the variation. A multiplicative time series Y can be represented as Y = Trend * Cycle * Seasonality * Noise.

Splitting a time series into its components is a widely employed technique for time data analysis. This is known as time series decomposition, and it also represents the foundation of time series forecasting.

One of the most useful commands is @where , which allows us to filter a data source so that only the elements that satisfy the condition are returned. Similar to @select , the condition can be any arbitrary Julia expression:

We get the following output:

Only bread has a qty smaller than 2.

Filtering can be made even more powerful by means of range variables. These act like new variables belonging to the query expression and can be introduced using the @let macro:

The output is as follows:

Here, you can see how, within the begin...end block, we defined a local variable called weekly_qty with a value equal to 7 * p.qty. We used the @let macro to introduce new variables. In the next line, we used it to filter out the rows that have a weekly_qty smaller than 10. And then finally, we selected it and collected it into a DataFrame.

Homebrew is a well-known package manager for macOS in the line of apt and yum on Linux. It's not really necessary for installing Julia, but it's worth setting it up as it can be very useful during development since it can seamlessly install database servers, libraries, and other components for your projects.

As per the instructions at https://brew.sh , it can be installed by running the following command in a Terminal window:

It might take a while but once Homebrew is installed, a new command-line utility, brew, will become available.

Finally, $ brew cask install julia will download and install the latest version of Julia. In the process, it will also link the julia binary to /usr/local/bin/julia so you can interact with the language from the command line by simply typing $ julia.

As soon as you get the confirmation that the installation was successful you can run $ julia to start a new REPL session:

Besides the help and the shell modes, there are two search modes. These are not necessarily Julia specific, being common to many *nix style editing apps.

Press the Ctrl key and the R key at the same time in order to initiate a reverse incremental search. The prompt will change to (reverse-i-search). Start typing your query and the most recent result will show. To find older results, type Ctrl + R again.

The counterpart of Ctrl + R is Ctrl + S, initiating an incremental search. The two may be used in conjunction to move through the previous or next matching results, respectively.

As we were saying, we need a way to retrieve the GitHub URI of a package, based on the package's name. Now, given that we're able to successfully execute operations such as add and develop with Pkg, without having to provide the GitHub URI, we can assume that there is a way to convert a package name to a package URL.

Indeed, Julia manages a repository of all the packages that are known to Pkg. These packages are grouped into multiple registries that are copied to your computer. By default, Julia comes with the so-called General registry, which can be found in the .julia/ folder in your home directory. The General registry itself is nothing but a folder that contains subfolders named after each letter in the English alphabet (thus, from A to Z). Within each of these folders, we can find all the packages whose names start with that letter: