Julia Programming Projects电子书

Title Page

Copyright and Credits

Julia Programming Projects

Dedication

About Packt

Why subscribe?

Packt.com

Contributors

About the author

About the reviewers

Packt is searching for authors like you

Preface

Who this book is for

What this book covers

To get the most out of this book

Download the example code files

Download the color images

Conventions used

Get in touch

Reviews

Getting Started with Julia Programming

Technical requirements

Why Julia?

Good performance

Concise, readable, and intuitive syntax

Powerful and productive dynamic type system

Designed for parallelism and distributed computation

Efficient intercommunication with other languages

Powerful REPL and shell-like capabilities

And more...

Installing Julia

Windows

Official Windows installer

Using Chocolatey

Windows Subsystem for Linux

macOS

Official image

Homebrew

Linux and FreeBSD

Docker

JuliaPro

JuliaBox

Choosing an IDE

Juno (Atom)

Visual Studio Code

IJulia (JuliaBox)

Other options

Getting started with Julia

The Julia REPL

Interacting with the REPL

The ans variable

Prompt pasting

Tab completion

Cleaning the REPL scope

Additional REPL modes

Accessing the documentation with the help mode

Shell mode

Search modes

The startup.jl file

REPL hooks

Exiting the REPL

The package system

Adding a package

OhMyREPL

Custom package installation

Revise

Checking the package status

Using packages

One more step

Updating packages

Pinning packages

Removing packages

Discovering packages

Registered versus unregistered

Summary

Creating Our First Julia App

Technical requirements

Defining variables

Constants

Why are constants important?

Comments

Strings

Triple-quoted strings

Concatenating strings

Interpolating strings

Manipulating strings

Unicode and UTF-8

Regular expressions

Raw string literals

Numbers

Integers

Overflow behavior

Floating-point numbers

Rational numbers

Numerical operators

Vectorized dot operators

There's more to it

Tuples

Named tuples

Ranges

Arrays

Iteration

Mutating arrays

Comprehensions

Generators

Exploratory data analysis with Julia

The Iris flower dataset

Using the RDatasets package

Using simple statistics to better understand our data

Visualizing the Iris flowers data

Loading and saving our data

Saving and loading using tabular file formats

Working with Feather files

Saving and loading with MongoDB

Summary

Setting Up the Wiki Game

Technical requirements

Data harvesting through web scraping

How the web works – a crash course

Making HTTP requests

Learning about HTTP methods

Understanding HTTPS

Understanding HTML documents

HTML selectors

Learning about the HTML attributes

Learning about CSS and JavaScript selectors

Understanding the structure of a link

Accessing the internet from Julia

Making requests with the HTTP package

Handling HTTP responses

HTTP status codes

Learning about HTTP headers

The HTTP message body

Understanding HTTP responses

The status code

The headers

The message body

Learning about pairs

Dictionaries

Constructing dictionaries

Ordered dictionaries

Working with dictionaries

Using the HTTP response

Manipulating the response body

Building a DOM representation of the page

Parsing HTML with Gumbo

Coding defensively

The pipe operator

Handling errors like a pro

The try...catch statements

The finally clause

Throwing exceptions on errors

Rethrowing exceptions

Learning about functions

The return keyword

Returning multiple values

Optional arguments

Keyword arguments

Documenting functions

Writing a basic web crawler – take one

Setting up our project

Writing a Julia program

Conditional evaluation of if, elseif, and else statements

The ternary operator

Short-circuit evaluation

Beware of operator precedence

Carrying on with the crawler's implementation

Summary

Building the Wiki Game Web Crawler

Technical requirements

Six Degrees of Wikipedia, the gameplay

Some additional requirements

Organizing our code

Using modules to tame our code

Defining modules

Productive REPL sessions with Julia

Setting up our modules

Referencing modules

Setting up the LOAD_PATH

Loading modules with using

Loading modules with import

Loading modules with include

Nesting modules

Setting up our game's architecture

Checking our code

Building our Wikipedia crawler - take two

Using blocks

Implementing the gameplay

Finishing touches

One more thing

Learning about Julia's type system

Defining our own types

Constructing types

Mutable composite types

Type hierarchy and inheritance

Type unions

Using article types

Inner constructors

Methods

Working with relational databases

Adding MySQL support

Connecting to the database

Setting up our Article module

Adding the persistence and retrieval methods

Putting it all together

Summary

Adding a Web UI for the Wiki Game

Technical requirements

The game plan

Learning about Julia's web stack

Beginning with a simple example – Hello World

Developing the game's web UI

Defining our routes

Preparing the landing page

Starting a new game

Extracting the difficulty settings from the page URL

Starting a new game session

Rendering the first Wikipedia article from the chain

Setting up in-article navigation

Displaying information about the game session

Displaying a Wikipedia article page

Navigating back up the article chain

Showing the solution

Handling any other requests

Wrapping it up

Summary

Implementing Recommender Systems with Julia

Technical requirements

Understanding recommender systems

Classifying recommender systems

Learning about non-personalized, stereotyped, and personalized recommendations

Understanding personalized recommendations

Explicit and implicit ratings

Understanding content-based recommender systems

Beginning with association-based recommendations

Learning about collaborative filtering

Understanding user-item CF

Item-item CF

Summary

Machine Learning for Recommender Systems

Technical requirements

Comparing the memory-based versus model-based recommenders

Learning about the model-based approach

Understanding our data

A first look at the data

Loading the data

Handling missing data

Data analysis and preparation

Training our data models

Scaling down our dataset

Training versus testing data

Machine learning-based recommendations

Making recommendations with Recommendation

Setting up the training data

Building and training the recommender

Matrix Factorization

Making recommendations

Testing the recommendations

Learning about hybrid recommender systems

Summary

Leveraging Unsupervised Learning Techniques

Technical requirements

Unsupervised machine learning

Clustering

Data analysis of the San Francisco business

Data wrangling with query

Metaprogramming in Julia

Learning about symbols and expressions in metaprogramming

Quoting expressions

Interpolating strings

Macros

Closing words about macros

Beginning with Query.jl basics

@from

@select

@collect

@where

@join

@group

@orderby

Preparing our data

Unsupervised machine learning with clustering

The k-means algorithm

Algorithm seeding

Finding the areas with the most businesses

Training our model

Interpreting the results

Refining our findings

Visualizing our clusters on the map

Using BatchGeo to quickly build maps of our data

Choosing the optimal number of clusters for k-means (and other algorithms)

Clustering validation

Summary

Working with Dates, Times, and Time Series

Technical requirements

Working with dates and times

Constructing dates and times

Parsing strings into dates and times

Formatting dates

Defining other locales

Working with date and time accessors

Querying dates

Defining the date ranges

Period types and period arithmetic

Date adjustments

Rounding of dates

Adding support for time zones

Converting time zones

Parsing date strings

ZonedDateTime period arithmetic

Time zone-aware date ranges

Time series data in Julia

A quick look at our data with Plots and PyPlot

The TimeArray type

Indexing the TimeArray objects

Querying TimeArray objects

The when() method

The from() method

The to() method

The findall() and findwhen() methods

Manipulating time series objects

merge()

The vcat() method

The collapse() method

The map() method

Summary

Time Series Forecasting

Technical requirements

A quick look at our data

Data processing

Understanding time series components

Trend

Seasonality

Random noise

Cyclicity

Time series decomposition

Explaining data – an additive approach or multiplicative approach?

Extracting the trend

Computing the seasonality

TimeSeries operators

Time series stationarity

Differencing a time series

Autocorrelation

Time series forecasting

Naïve

Simple average

Moving average

Linear regression

Closing thoughts

Summary

Creating Julia Packages

Technical requirements

Creating a new Julia package

Generating packages

The Project.toml file

The src folder and the main module

Using our new package

Defining the requirements for our package

Beginning with test-driven Julia development

Peeking into Julia's registry

Working with TOML files

The IssueReporter.jl package

Performance testing

Benchmarking tools

Type stability is key

Benchmarking our code

Interacting with the GitHub API

Authenticating with the GitHub API

Reporting GitHub issues

Documenting our package

Advanced documentation tips

Generating the documentation

Registering our package

Finishing touches

Setting up the repository

Unleashing Julia's army of bots

Summary

Other Books You May Enjoy

Leave a review - let other readers know what you think