Julia Programming for Machine Learning

Learn Julia's core datatypes: integers, floating point numbers, and rational numbers, covering type checks with typeof, ranges of values, and conversions using round, ceil, floor, numerator, denominator, rationalize.

Explore how Julia classifies integers, floats, and rationals under Real, Number, and Any, and distinguish primitive from abstract types. Learn real-number arithmetic using +, -, *, /, \, div, ^.

Create 4 + 2im in julia and inspect real and imaginary parts. Use constructors, compute abs and angle, and note that division or modulo is not allowed on complex numbers.

Explore how Julia represents booleans, with true as 1 and false as 0, and use in, isa, comparisons, and predicates with not, and, or to govern logic.

Learn how Julia represents strings and characters, including string literals, single-quoted chars, escape sequences, and Unicode handling; perform concatenation, interpolation, substring extraction, splitting, and replacement with practical examples.

Explore how colon-prefixed syntax creates symbols and expressions in Julia, using Symbol(), Expr, and metaprogramming with Meta.parse and eval to evaluate expressions.

Learn to read user input in Julia with input() and readline(), convert inputs to Float64, and compute the sum of squares. Use @sprintf (Printf) for formatted output and include scripts.

Learn to perform basic input/output in Julia, parse three side lengths, compute the triangle area using the semi-perimeter and sqrt(s*(s-a)*(s-b)*(s-c)), and format the result with @sprintf.

Explore how tuples in Julia represent fixed, immutable data, including mixed-type and named tuples with indexing, dot notation, missing values, and merging capabilities.

Explore how dot syntax enables elementwise broadcasting on tuples in Julia, performing arithmetic, functions, comparisons, and logical operations elementwise on same-length tuples, with fusing dot operators.

Learn to create and mutate one-dimensional arrays (vectors) in Julia, including in-place updates with replace, push!, and splice. Explore vector operations, broadcasting with dot syntax, and range-based creation via collect.

Explore 2D arrays and matrices in Julia: create, index, replace, extract submatrices, flatten and reshape, and perform element-wise and matrix multiplication, with zeros, ones, fill, identity, random matrices, and det.

Explore constructing and manipulating multi-dimensional arrays in Julia, from vectors and matrices to three- and four-dimensional tensors, using reshape, indexing, subarrays, and in-place updates with copy and fill!

Extract and transpose 2x2 submatrices from arr10. Use vcat or hcat to form a 4-by-2 matrix with rows 24 22, 12 10, 15 13, 3 1, in Julia.

Construct and mutate dictionaries in Julia by pairing keys with values, using Dict and various constructors, then update, access, and verify keys with haskey and in.

Julia programming for machine learning: map digits to words using a dictionary dt, read a number, convert digits with array comprehension, and print the result in repl.

Learn to connect a folder to the Julia console, set the working directory, and perform file I/O by creating, writing, appending, and reading files with open, readdir, and read.

Fix the working directory, read text_data as a string in Julia, and answer five questions; then solve four equations in x, y, z, w and print results via a dictionary.

Set the working directory, read text_data.txt in Julia, and use a REPL to compute metrics: characters, lines, words, and the word 'the' occurrences, plus a regex-based alphabetic count after removal.

Solve four linear equations by the matrix inversion method in Julia, constructing a 4x4 matrix A and vector B, then map x, y, z, w with Dict and display results.

Explore how compound expressions simplify control flow in Julia, using begin end blocks, semicolon chains, and parentheses to perform calculations and evaluate results.

Explore if-else and elseif syntax in Julia, with a ternary operator. Determine triangle types: equilateral, isosceles, scalene; get inputs from the user and validate side lengths.

Explore a Julia program that reads three triangle side lengths, validates them with all() and a+b>c checks, and classifies the triangle as equilateral, isosceles, or scalene.

Explore for loops in Julia, from ranges to matrices and strings, including nested loops, and create a program to select numbers divisible by 3 or 5 but not both.

Explore the break and continue in Julia to control loop iterations. See how break stops at a condition and continue skips characters, with vowels and consonants illustrated.

Convert a Julia for loop to a while loop, manage a counter i, apply break, and practice with an array to print numbers until a value divisible by 17.

Write a Julia program that prints array elements up to the first number divisible by 17, which is 51, using a while loop and a global index i.

master exception handling in julia by validating inputs, using try catch for input errors, and delivering friendly messages for gcd and lcm computations on integers, rationals, and complex numbers.

Build a Julia card-deck picker game with five attempts to match a machine's value and an interval prime finder that lists primes or shows relevant error messages.

Convert numeric card_val array values to strings, select a random value with rand, and guess the machine’s card value within five attempts using input validation.

Create a Julia prime finder that reads an interval, validates bounds as natural integers, uses any() to test primality, and prints primes or a no-primes message.

Define and use anonymous functions in julia, assign them to variables, and apply them to single or multiple arguments; explore multiple dispatch, composite types, and constructors.

Explore map, filter, and reduce in Julia using anonymous functions, the do keyword, and pipe-based function composition to transform ranges, tuples, and two- or three-variable inputs.

Define and use functions with positional and keyword arguments in Julia, explore round and passing values to map, filter, and reduce, and leverage range, vector creation, and return semantics.

Define functions with multiple arguments and convert z to a keyword argument using a semicolon, then assign a default value to z to make it optional.

Define fn7 with mandatory args a, b, c and optional kw1, kw2; assert types with double colons: a,b integers, c float, kw1 integer, kw2 string, plus REPL demonstrations.

Explore varargs functions in Julia, defining functions with a variable number of arguments using an ellipsis and a tuple. Also handle arbitrary keyword arguments via kwargs as a NamedTuple.

Explore how Julia implements multiple dispatch by defining a single function with multiple methods for various argument types, enabling dynamic dispatch and flexible input combos.

Explore Julia's primitive and composite types, define a CartesianPoints struct, instantiate points, and use mutable versus immutable types to access and modify coordinates x and y.

Define abstract and composite types in Julia, create Points2D and Points3D with x, y, and z, and extend dist with multiple methods to compute 2D, 3D, and origin distances.

Learn two Julia tasks: implement find_num for primes or squares in Int16 with typed and optional args, and create a Shapes hierarchy to compute area and perimeter via area_peri.

Explore metaprogramming in Julia by constructing expressions with Meta.parse and Expr() constructor, using macros and Polish notation, then evaluate with eval to transform strings into executable code.

Explore Julia's Expr() constructor by inspecting ASTs, symbols, and :call heads, then build expressions using Polish (prefix) notation and the expression constructor to reproduce results.

Discover how the Julia compiler converts strings to code, then use metaprogramming to inspect abstract syntax trees and construct expressions with polish notation via Meta.parse and eval.

Construct expression objects with Polish notation to mirror Julia's compiler interpretation of compound expressions, build subexpressions like l=5, m=6, n=7, and validate results using Meta.parse and begin blocks.

Construct expression object xpr5 with the Expression constructor, build sub-expressions a = 2, b = 3, c = 4, and a multiplied by b plus c, then evaluate to 10.

Learn to construct Julia expressions using quote blocks and the Expression constructor with Polish notation, then inspect the AST with dump and run via eval.

Explore Julia macros such as @elapsed, @allocated, and @which to measure time, memory, and locate code origins. See @eval and @sprintf from the Printf library for formatting and evaluating expressions.

Define enumerated types with Julia's @enum macro, creating Quadrilateral and Polygon with instances like square and triangle; use instances() to view their values and define a function to print them.

Create and use macros in julia by defining @hello and @fnvalue, exploring macro arguments, and extending with multiple methods, while inspecting results with @macroexpand and @macroexpound.

Learn how Julia macros generate code before runtime, ensure hygiene, and use quote blocks and esc to control evaluation, with my_num and jumble examples.

Create a @fibo macro in Julia to generate fibonacci numbers using three arguments: n, init, and block, and run it in REPL to produce output.

Explore how Julia handles matrices in linear algebra, including creating, indexing, reshaping, and rotating matrices, and understand determinant, rank, square, singular, and full-rank matrices.

Explore how Julia identifies and constructs matrices with special structures, including lower and upper triangular, diagonal, tri-diagonal, bi-diagonal, Hessenberg, symmetric, and hermitian, using LinearAlgebra.

Explore eigenvalues and eigenvectors of matrices, construct eigenfactorizations with Julia, and learn diagonalization, spectral decomposition, and properties for symmetric and positive definite matrices.

Explore sparse matrices and vectors in Julia, focusing on memory efficiency with sparse() and CSC storage. Learn LU, Cholesky, LDLt, and QR factorizations for sparse matrices and related permutations.

Explore rank and null space in Julia by linking matrix representations to linear transformations, using rank(), nullspace(), and nonzero singular values to define image and kernel.

Discover how to manipulate tabular data in Julia using the DataFrames and CSV packages, and learn to install these packages with Pkg and JuliaPro for data analysis.

Create and manipulate julia data frames with the DataFrames package, from empty frames to adding letter and index columns, constructing from vectors or dicts, and comparing df1, df2, df3.

Learn to import and read data as a DataFrame in Julia using CSV and DataFrames. Explore Occupation.csv with 153 rows and 6 columns, manipulating columns by name, index, or regex.

Learn to filter data frames in Julia by age, work experience, state, and profession with logical arrays, then sort by name, age, and profession using length and reverse options.

Load CSV and DataFrames modules, import Occupation data as df, add a ratio column from work experience divided by age rounded to 3 decimals, and reshape with stack and unstack.

Learn to manipulate Julia data frames by importing occupation data, selecting and mutating name and profession columns with dot syntax, boolean indexing, and conditional updates.

Apply the split-apply-combine approach to a data frame by grouping by profession (and sex and state), applying functions like nrow, mean age, and cor, and compiling aggregate statistics.

Identify missing entries in a Julia data frame and decide between dropping affected rows or columns, or imputing with mean or median values to preserve predictive accuracy.

Impute missing data in a Julia data frame with a for loop to fill age and work experience means, then group by profession and sex to compute correlations and counts.

Learn to work with dates and times in Julia using the Dates module. Build Date, DateTime, and Time objects, format them, and extract components for time series in time zones.

Explore Julia's dates module to query leap years, day of year, quarters, and month or day names, switch locales such as Spanish, and use adjusters, rounding, ranges, and weekend filtering.

Study Julia's Dates module export list and use now, today, Date, Time, and DateTime to compute durations; create, convert, and compare Period and CompoundPeriod objects for date arithmetic.

Install the TimeZones package and use now() to view local and UTC times; learn about fixed vs variable time zones, DST transitions, and ZonedDateTime.

Create time series data in Julia using a date-time range and a data frame. Convert timestamps to month-year, compute month-wise aggregates, and visualize trends with TimeSeries and StatsPlots.

Learn to create and access time series data in Julia with TimeArray, generating random observations, constructing from timestamps, renaming columns, plotting trends, and indexing by dates and columns.

Learn to filter and aggregate TimeArray data in Julia's TimeSeries module using when, findwhen, findall, and in to query days, weeks, quarters, and weekdays.

Explores time-series manipulation with TimeArray in Julia, covering lag(), lead(), diff(), percentchange(), moving() and map() transformations, and exporting results; introduces halfofyour() and tertileofyear() functions and anonymous moving-window design.

Consolidate four olist datasets into a unified dataframe and time array to analyze orders, revenues, and customer activity in Brazil. Prepare to answer key location and revenue queries.

Load and preprocess olist data using Julia, convert Portuguese product categories to English, aggregate order costs by order id, adjust timestamps to Brazil time, and build a consolidated dataframe.

Identify the most frequent buyer in the olist data using a DataFrame and TimeArray, then compute spend by product_category and track purchase_timestamp with groupby operations.

Analyze olist data by city, day_name, and hour using groupby to identify top cities like Sao Paulo, peak days, and peak hours; visualize daywise and hourly revenue.

Analyze e-commerce data with TimeArray-driven visualizations across five Brazilian cities. Compare monthly revenue and items purchased, and examine moving-window trends in revenue and orders from Olist.

Visualize order time intervals using the TimeArray olist_ta with two side-by-side plots for five Brazilian cities and global customers, then map 73 categories to 7 timeslots and 8 weekdays.

Explore regression analysis with Julia by building models from real-world datasets to predict numeric responses from independent variables.

Explore linear regression using the least squares method to minimize residuals and derive the regression line y = ax + b for simple and multiple regression.

Explore building a simple linear regression in Julia using the Body_Brain_Wt.csv dataset to predict brain weight from body weight, with a training and test split and a regression line plot.

Set working directory, import body brain weight CSV, create 2-column df with body weight independent and brain weight dependent, then split into training and test sets with shuffle for reproducibility.

Build a simple linear regression in Julia with glm, predicting brain weight from body weight. Assess significance, fit, and residuals using p-values, t-tests, and r-squared.

Apply simple linear regression in Julia to predict brain weight from body weight, compare actual brain weights vs predicted on the test set, and visualize training and test plots.

Build a multiple linear regression model in Julia to predict medical insurance charges from age, bmi, children, sex, smoker, and region, with data import, encoding, and train-test split.

Learn to encode categorical variables with label encoding, one-hot encoding, and dummy coding, then build a Julia linear regression model with eight coefficients to predict charges.

Build a multiple linear regression model in Julia using the medical insurance cost data, performing data import, preprocessing, encoding of categorical variables, and preparing train/test split.

Build a Julia GLM multiple linear regression with region dummy coding, evaluate with r-squared and residuals, refine by omitting sex, apply log transform, predict on test set, and export results.

Explore polynomial regression to fit curves to data, extending simple linear regression with higher degrees using least squares. Relate years of experience to salary by estimating coefficients a0, a1, a2.

Develop a polynomial regression model to predict CTC from years of experience, convert the first column to numeric, split data into training and test sets, and visualize results.

Build a polynomial regression model in Julia by preprocessing data, cleaning the Years column, and refining terms up to the fourth power using GLM, with r-squared and p-values.

Develop and evaluate a polynomial regression model in Julia for predicting CTC values, using predict, round, and a comparison dataframe to assess accuracy against test data.