Machine Learning Guide

O'Reilly's 2017 Data Science Salary Survey finds that location is the most significant salary determinant for data professionals, with median salaries ranging from $134,000 in California to under $30,000 in Eastern Europe, and highlights that negotiation skills can lead to salary differences as high as $45,000. Other key factors impacting earnings include company age and size, job title, industry, and education, while popular tools and languages—such as Python, SQL, and Spark—do not strongly influence salary despite widespread use.

Links

• Notes and resources at ocdevel.com/mlg/mla-6
• Try a walking desk stay healthy & sharp while you learn & code

Global and Regional Salary Differences

• Median Global Salary: $90,000 USD, up from $85,000 the previous year.
• Regional Breakdown:
  • United States: $112,000 median; California leads at $134,000.
  • Western Europe: $57,000—about half the US median.
  • Australia & New Zealand: Second after the US.
  • Eastern Europe: Below $30,000.
  • Asia: Wide interquartile salary range, indicating high variability.

Demographic and Personal Factors

• Gender: Women's median salaries are $8,000 lower than men's. Women make up 20% of respondents but are increasing in number.
• Age & Experience: Higher age/experience correlates with higher salaries, but the proportion of older professionals declines.
• Education: Nearly all respondents have at least a master's; PhD holders earn only about $5,000 more than those with a master's.
• Negotiation Skills: Self-reported strong salary negotiation skills are linked to $45,000 higher median salaries (from $70,000 for lowest to $115,000 for highest bargaining skill).

Industry, Company, and Role

• Industry Impact:
  • Highest salaries found in search/social networking and media/entertainment.
  • Education and non-profit offer the lowest pay.
• Company Age & Size:
  • Companies aged 2–5 years offer higher than average pay; less than 2 years old offer much lower salaries (~$40,000).
  • Large organizations generally pay more.
• Job Title:
  • "Data scientist" and "data analyst" titles carry higher medians than "engineer" titles by around $7,000.
  • Executive titles (CTO, VP, Director) see the highest pay, with CTOs at $150,000 median.

Tools, Languages, and Technologies

• Operating Systems:
  • Windows: 67% usage, but declining.
  • Linux: 55%; Unix: 18%; macOS: 46%; Unix-based systems are rising in use.
• Programming Languages:
  • SQL: 64% (most used for database querying).
  • Python: 63% (most popular procedural language).
  • R: 54%.
  • Others (Java, Scala, C/C++, C#): Each less than 20%.
  • Salary difference across languages is minor; C/C++ users earn more but not enough to outweigh the difficulty.
• Databases:
  • MySQL (37%), MS SQL Server (30%), PostgreSQL (28%).
  • Popularity of the database has little impact on pay.
• Big Data and Search Tools:
  • Spark: Most popular big data platform, especially for large-scale data processing.
  • Elasticsearch: Most common search engine, but Solr pays more.
• Machine Learning Libraries:
  • Scikit-learn (37%) and Spark MLlib (16%) are most used.
• Visualization Tools:
  • R's ggplot2 and Python's matplotlib are leading choices.

Key Salary Differentiators (per Machine Learning Analysis)

• Top Predictors (explaining ~60% of salary variance):
  • World/US region
  • Experience
  • Gender
  • Company size
  • Education (but amounting to only ~$5,000 difference)
  • Job title
  • Industry
• Lesser Impact: Specific tools, languages, and databases do not meaningfully affect salary.

Summary Takeaways

• The greatest leverage for a higher salary comes from geography and individual negotiation capability, with up to $45,000 differences possible.
• Role/title selection, industry, company age, and size are also significant, while mastering the most commonly used tools is essential but does not strongly differentiate pay.
• For aspiring data professionals: focus on developing negotiation skills and, where possible, optimize for location and title to maximize earning potential.

Explains the fundamental differences between tensor dimensions, size, and shape, clarifying frequent misconceptions—such as the distinction between the number of features ("columns") and true data dimensions—while also demystifying reshaping operations like expand_dims, squeeze, and transpose in NumPy. Through practical examples from images and natural language processing, listeners learn how to manipulate tensors to match model requirements, including scenarios like adding dummy dimensions for grayscale images or reordering axes for sequence data.

Links

• Notes and resources at ocdevel.com/mlg/mla-5
• Try a walking desk stay healthy & sharp while you learn & code

Definitions

• Tensor: A general term for an array of any number of dimensions.

  • 0D Tensor (Scalar): A single number (e.g., 5).
  • 1D Tensor (Vector): A simple list of numbers.
  • 2D Tensor (Matrix): A grid of numbers (rows and columns).
  • 3D+ Tensors: Higher-dimensional arrays, such as images or batches of images.

• NDArray (NumPy): Stands for "N-dimensional array," the foundational array type in NumPy, synonymous with "tensor."

Tensor Properties Dimensions

• Number of nested levels in the array (e.g., a matrix has two dimensions: rows and columns).
• Access in NumPy: Via .ndim property (e.g., array.ndim).

Size

• Total number of elements in the tensor.
• Examples:
  • Scalar: size = 1
  • Vector: size equals number of elements (e.g., 5 for [1, 2, 3, 4, 5])
  • Matrix: size = rows × columns (e.g., 10×10 = 100)
• Access in NumPy: Via .size property.

Shape

• Tuple listing the number of elements per dimension.
• Example: An image with 256×256 pixels and 3 color channels has shape = (256, 256, 3).

Common Scenarios & Examples Data Structures in Practice

• CSV/Spreadsheet Example: Dataset with 1 million housing examples and 50 features:
  • Shape: (1_000_000, 50)
  • Size: 50,000,000
• Image Example (RGB): 256×256 pixel image:
  • Shape: (256, 256, 3)
  • Dimensions: 3 (width, height, channels)
• Batching for Models:
  • For a convolutional neural network, shape might become (batch_size, width, height, channels), e.g., (32, 256, 256, 3).

Conceptual Clarifications

• The term "dimensions" in data science often refers to features (columns), but technically in tensors it means the number of structural axes.
• The "curse of dimensionality" often uses "dimensions" to refer to features, not tensor axes.

Reshaping and Manipulation in NumPy Reshaping Tensors

• Adding Dimensions:

  • Useful when a model expects higher-dimensional input than currently available (e.g., converting grayscale image from shape (256, 256) to (256, 256, 1)).
  • Use np.expand_dims or array.reshape.

• Removing Singleton Dimensions:

  • Occurs when, for example, model output is (N, 1) and single dimension should be removed to yield (N,).
  • Use np.squeeze or array.reshape.

• Wildcard with -1:

  • In reshaping, -1 is a placeholder for NumPy to infer the correct size, useful when batch size or another dimension is variable.

• Flattening:

  • Use np.ravel to turn a multi-dimensional tensor into a contiguous 1D array.

Axis Reordering

• Transposing Axes:
  • Needed when model input or output expects axes in a different order (e.g., sequence length and embedding dimensions in NLP).
  • Use np.transpose for general axis permutations.
  • Use np.swapaxes to swap two specific axes but prefer transpose for clarity and flexibility.

Practical Example

• In NLP sequence models:
  • 3D tensor with (batch_size, sequence_length, embedding_dim) might need to be reordered to (batch_size, embedding_dim, sequence_length) for certain models.
  • Achieved using: array.transpose(0, 2, 1)

Core NumPy Functions for Manipulation

• reshape: General function for changing the shape of a tensor, including adding or removing dimensions.
• expand_dims: Adds a new axis with size 1.
• squeeze: Removes axes with size 1.
• ravel: Flattens to 1D.
• transpose: Changes the order of axes.
• swapaxes: Swaps specified axes (less general than transpose).

Summary Table of Operations Operation NumPy Function Purpose Add dimension np.expand_dims Convert (256,256) to (256,256,1) Remove dimension np.squeeze Convert (N,1) to (N,) General reshape np.reshape Any change matching total size Flatten np.ravel Convert (a,b) to (a*b,) Swap axes np.swapaxes Exchange positions of two axes Permute axes np.transpose Reorder any sequence of axes Closing Notes

• A deep understanding of tensor structure - dimensions, size, and shape - is vital for preparing data for machine learning models.
• Reshaping, expanding, squeezing, and transposing tensors are everyday tasks in model development, especially for adapting standard datasets and models to each other.

Practical workflow of loading, cleaning, and storing large datasets for machine learning, moving from ingesting raw CSVs or JSON files with pandas to saving processed datasets and neural network weights using HDF5 for efficient numerical storage. It clearly distinguishes among storage options—explaining when to use HDF5, pickle files, or SQL databases—while highlighting how libraries like pandas, TensorFlow, and Keras interact with these formats and why these choices matter for production pipelines.

Links

• Notes and resources at ocdevel.com/mlg/mla-3
• Try a walking desk stay healthy & sharp while you learn & code

Data Ingestion and Preprocessing

• Data Sources and Formats:

  • Datasets commonly originate as CSV (comma-separated values), TSV (tab-separated values), fixed-width files (FWF), JSON from APIs, or directly from databases.
  • Typical applications include structured data (e.g., real estate features) or unstructured data (e.g., natural language corpora for sentiment analysis).

• Pandas as the Core Ingestion Tool:

  • Pandas provides versatile functions such as read_csv, read_json, and others to load various file formats with robust options for handling edge cases (e.g., file encodings, missing values).
  • After loading, data cleaning is performed using pandas: dropping or imputing missing values, converting booleans and categorical columns to numeric form.

• Data Encoding for Machine Learning:

  • All features must be numerical before being supplied to machine learning models like TensorFlow or Keras.
  • Categorical data is one-hot encoded using pandas.get_dummies, converting strings to binary indicator columns.
  • The underlying NumPy array of a DataFrame is accessed via df.values for direct integration with modeling libraries.

Numerical Data Storage Options

• HDF5 for Storing Processed Arrays:

  • HDF5 (Hierarchical Data Format version 5) enables efficient storage of large multidimensional NumPy arrays.
  • Libraries like h5py and built-in pandas functions (to_hdf) allow seamless saving and retrieval of arrays or DataFrames.
  • TensorFlow and Keras use HDF5 by default to store neural network weights as multi-dimensional arrays for model checkpointing and early stopping, accommodating robust recovery and rollback.

• Pickle for Python Objects:

  • Python's pickle protocol serializes arbitrary objects, including machine learning models and arrays, into files for later retrieval.
  • While convenient for quick iterations or heterogeneous data, pickle is less efficient with NDarrays compared to HDF5, lacks significant compression, and poses security risks if not properly safeguarded.

• SQL Databases and Spreadsheets:

  • For mixed or heterogeneous data, or when producing results for sharing and collaboration, relational databases like PostgreSQL or spreadsheets such as CSVs are used.
  • Databases serve as the endpoint for production systems, where model outputs—such as generated recommendations or reports—are published for downstream use.

Storage Workflow in Machine Learning Pipelines

• Typical Process:

  • Data is initially loaded and processed with pandas, then converted to numerical arrays suitable for model training.
  • Intermediate states and model weights are saved using HDF5 during model development and training, ensuring recovery from interruptions and facilitating early stopping.
  • Final outputs, especially those requiring sharing or production use, are published to SQL databases or shared as spreadsheet files.

• Best Practices and Progression:

  • Quick project starts may involve pickle for accessible storage during early experimentation.
  • For large-scale, high-performance applications, migration to HDF5 for numerical data and SQL for production-grade results is recommended.
  • Alternative options like Feather and PyTables (an interface on top of HDF5) exist for specialized needs.

Summary

• HDF5 is optimal for numerical array storage due to its efficiency, built-in compression, and integration with major machine learning frameworks.
• Pickle accommodates arbitrary Python objects but is suboptimal for numerical data persistence or security.
• SQL databases and spreadsheets are used for disseminating results, especially when human consumption or application integration is required.
• The selection of a storage format is determined by data type, pipeline stage, and end-use requirements within machine learning workflows.

NumPy enables efficient storage and vectorized computation on large numerical datasets in RAM by leveraging contiguous memory allocation and low-level C/Fortran libraries, drastically reducing memory footprint compared to native Python lists. Pandas, built on top of NumPy, introduces labelled, flexible tabular data manipulation—facilitating intuitive row and column operations, powerful indexing, and seamless handling of missing data through tools like alignment, reindexing, and imputation.

Links

• Notes and resources at ocdevel.com/mlg/mla-2
• Try a walking desk stay healthy & sharp while you learn & code

NumPy: Efficient Numerical Arrays and Vectorized Computation

• Purpose and Design

  • NumPy ("Numerical Python") is the foundational library for handling large numerical datasets in RAM.
  • It introduces the ndarray (n-dimensional array), which is synonymous with a tensor—enabling storage of vectors, matrices, or higher-dimensional data.

• Memory Efficiency

  • NumPy arrays are homogeneous: all elements share a consistent data type (e.g., float64, int32, bool).
  • This data type awareness enables allocation of tightly-packed, contiguous memory blocks, optimizing both RAM usage and data access speed.
  • Memory footprint can be orders of magnitude lower than equivalent native Python lists; for example, tasks that exhausted 32GB of RAM using Python lists could drop to just 6GB with NumPy structures.

• Vectorized Operations

  • NumPy supports vectorized calculations: operations (such as squaring all elements) are applied across entire arrays in a single step, without explicit Python loops.
  • These operations are operator-overloaded and are executed by delegating instructions to low-level, highly optimized C or Fortran routines, delivering significant computational speed gains.
  • Conditional operations and masking, such as zeroing out negative numbers (akin to a ReLU activation), can be done efficiently with Boolean masks.

Pandas: Advanced Tabular Data Manipulation

• Relationship to NumPy

  • Pandas builds upon NumPy, leveraging its underlying optimized array storage and computation for numerical columns in its data structures.
  • Supports additional types like strings for non-numeric data, which are common in real-world datasets.

• 2D Data Handling and Directional Operations

  • The core Pandas structure is the DataFrame, which handles labelled rows and columns, analogous to a spreadsheet or SQL table.
  • Operations are equally intuitive row-wise and column-wise, facilitating both SQL-like ("row-oriented") and "columnar" manipulations.
  • This dual-orientation enables many complex data transformations to be succinct one-liners instead of lengthy Python code.

• Indexing and Alignment

  • Pandas uses flexible and powerful indexing, enabling functions such as joining disparate datasets via a shared index (e.g., timestamp alignment in financial time series).
  • When merging DataFrames (e.g., two stocks with differing trading days), Pandas automatically aligns data on the index, introducing NaN (null) values for unmatched dates.

• Handling Missing Data (Imputation)

  • Pandas includes robust features for detecting and filling missing values, known as imputation.
    • Options include forward filling, backfilling, or interpolating missing values based on surrounding data.
  • Datasets can be reindexed against standardized sequences, such as all valid trading days, to enforce consistent time frames and further identify or fill data gaps.

• Use Cases and Integration

  • Pandas simplifies ETL (extract, transform, load) for CSV and database-derived data, merging NumPy's computation power with tools for advanced data cleaning and integration.
  • When preparing data for machine learning frameworks (e.g., TensorFlow or Keras), Pandas DataFrames can be converted back into NumPy arrays for computation, maintaining tight integration across the data science stack.

Summary: NumPy underpins high-speed numerical operations and memory efficiency, while Pandas extends these capabilities to powerful, flexible, and intuitive manipulation of labelled multi-dimensional data -together forming the backbone of data analysis and preparation in Python machine learning workflows.

While industry-respected credentials like Udacity Nanodegrees help build a practical portfolio for machine learning job interviews, they remain insufficient stand-alone qualifications—most roles require a Master's degree as a near-hard requirement, especially compared to more flexible web development fields. A Master's, such as Georgia Tech's OMSCS, not only greatly increases employability but is strongly recommended for those aiming for entry into machine learning careers, while a PhD is more appropriate for advanced, research-focused roles with significant time investment.

Links

• Notes and resources at ocdevel.com/mlg/mla-1

Online Certificates: Usefulness and Limitations

• Udacity Nanodegree

  • Provides valuable hands-on experience and a practical portfolio of machine learning projects.
  • Demonstrates self-motivation and the ability to self-teach.
  • Not industry-recognized as a formal qualification—does not by itself suffice for job placement in most companies.
  • Best used as a supplement to demonstrate applied skills, especially in interviews where coding portfolios (e.g., on GitHub) are essential.

• Coursera Specializations

  • Another MOOC resource similar to Udacity, but Udacity's Nanodegree is cited as closer to real-world relevance among certificates.
  • Neither is accredited or currently accepted as a substitute for formal university degrees by most employers.

The Role of a Portfolio

• Possessing a portfolio with multiple sophisticated projects is critical, regardless of educational background.
• Interviewers expect examples showcasing data processing (e.g., with Pandas and NumPy), analysis, and end-to-end modeling using libraries like scikit-learn or TensorFlow.

Degree Requirements in Machine Learning

• Bachelor's Degree

  • Often sufficient for software engineering and web development roles but generally inadequate for machine learning positions.
  • In web development, non-CS backgrounds and bootcamp graduates are commonplace; the requirement is flexible.
  • Machine learning employers treat "Master's preferred" as a near-required credential, sharply contrasting with the lax standards in web and mobile development.

• Master's Degree

  • Significantly improves employability and is typically expected for most machine learning roles.
  • The Georgia Tech Online Master of Science in Computer Science (OMSCS) is highlighted as a cost-effective, flexible, and industry-recognized path.
  • Industry recruiters often filter out candidates without a master's, making advancement with only a bachelor's degree an uphill struggle.
  • A master's degree reduces obstacles and levels the playing field with other candidates.

• PhD

  • Necessary mainly for highly research-centric positions at elite companies (e.g., Google, OpenAI).
  • Opens doors to advanced research and high salaries (often $300,000+ per year in leading tech sectors).
  • Involves years of extensive commitment; suitable mainly for those with a passion for research.

Recommendations

• For Aspiring Machine Learning Professionals:

  • Start with a bachelor's if you don't already have one.
  • Strongly consider a master's degree (such as OMSCS) for solid industry entry.
  • Only pursue a PhD if intent on working in cutting-edge research roles.
  • Always build and maintain a robust portfolio to supplement academic achievements.

• Summary Insight:

  • A master's degree is becoming the de facto entry ticket to machine learning careers, with MOOCs and portfolios providing crucial, but secondary, support.

Notes and resources: ocdevel.com/mlg/29

Try a walking desk to stay healthy while you study or work!

Reinforcement Learning (RL) is a fundamental component of artificial intelligence, different from purely being AI itself. It is considered a key aspect of AI due to its ability to learn through interactions with the environment using a system of rewards and punishments.

Links:

• openai/baselines
• reinforceio/tensorforce
• NervanaSystems/coach
• rll/rllab
• Differential Computers

Concepts and Definitions

• Reinforcement Learning (RL):
  • RL is a framework where an "agent" learns by interacting with its environment and receiving feedback in the form of rewards or punishments.
  • It is part of the broader machine learning category, which includes supervised and unsupervised learning.
  • Unlike supervised learning, where a model learns from labeled data, RL focuses on decision-making and goal achievement.

Comparison with Other Learning Types

• Supervised Learning:
  • Involves a teacher-student paradigm where models are trained on labeled data.
  • Common in applications like image recognition and language processing.
• Unsupervised Learning:
  • Not commonly used in practical applications according to the experience shared in the episode.
• Reinforcement Learning vs. Supervised Learning:
  • RL allows agents to learn independently through interaction, unlike supervised learning where training occurs with labeled data.

Applications of Reinforcement Learning

• Games and Simulations:
  • Deep reinforcement learning is used in games like Go (AlphaGo) and video games, where the environment and possible rewards or penalties are predefined.
• Robotics and Autonomous Systems:
  • Examples include robotics (e.g., Boston Dynamics mules) and autonomous vehicles that learn to navigate and make decisions in real-world environments.
• Finance and Trading:
  • Utilized for modeling trading strategies that aim to optimize financial returns over time, although breakthrough performance in trading isn't yet evidenced.

RL Frameworks and Environments

• Framework Examples:
  • OpenAI Baselines, TensorForce, and Intel's Coach, each with different capabilities and company backing for development.
• Environments:
  • OpenAI's Gym is a suite of environments used for training RL agents.

Future Aspects and Developments

• Model-based vs. Model-free RL:
  • Model-based RL involves planning and knowledge of the world dynamics, while model-free is about reaction and immediate responses.
• Remaining Challenges:
  • Current hurdles in AI include reasoning, knowledge representation, and memory, where efforts are ongoing in institutions like Google DeepMind for further advancement.

Notes and resources: ocdevel.com/mlg/28

Try a walking desk to stay healthy while you study or work!

More hyperparameters for optimizing neural networks. A focus on regularization, optimizers, feature scaling, and hyperparameter search methods.

Hyperparameter Search Techniques

• Grid Search involves testing all possible permutations of hyperparameters, but is computationally exhaustive and suited for simpler, less time-consuming models.
• Random Search selects random combinations of hyperparameters, potentially saving time while potentially missing the optimal solution.
• Bayesian Optimization employs machine learning to continuously update and hone in on efficient hyperparameter combinations, avoiding the exhaustive or random nature of grid and random searches.

Regularization in Neural Networks

• L1 and L2 Regularization penalize certain parameter configurations to prevent model overfitting; often smoothing overfitted parameters.
• Dropout randomly deactivates neurons during training to ensure the model doesn't over-rely on specific neurons, fostering better generalization.

Optimizers

• Optimizers like Adam, which combines elements of momentum and adaptive learning rates, are explained as vital tools for refining the learning process of neural networks.
• Adam, being the most sophisticated and commonly used optimizer, improves upon simpler techniques like momentum by incorporating more advanced adaptative features.

Initializers

• The importance of weight initialization is underscored with methods like uniform random initialization and the more advanced Xavier initialization to prevent neural networks from starting in 'stuck' states.

Feature Scaling

• Different scaling methods such as standardization and normalization are used to scale feature inputs to small, standardized ranges.
• Batch Normalization is highlighted, integrating scaling directly into the network to prevent issues like exploding and vanishing gradients through the normalization of layer outputs.

Links

• Bayesian Optimization
• Optimizers (SGD): Momentum -> Adagrad -> RMSProp -> Adam -> Nadam

Full notes and resources at ocdevel.com/mlg/27

Try a walking desk to stay healthy while you study or work!

Hyperparameters are crucial elements in the configuration of machine learning models. Unlike parameters, which are learned by the model during training, hyperparameters are set by humans before the learning process begins. They are the knobs and dials that humans can control to influence the training and performance of machine learning models.

Definition and Importance

Hyperparameters differ from parameters like theta in linear and logistic regression, which are learned weights. They are choices made by humans, such as the type of model, number of neurons in a layer, or the model architecture. These choices can have significant effects on the model's performance, making them vital to conscious and informed tuning.

Types of Hyperparameters Model Selection:

Choosing what model to use is itself a hyperparameter. For example, deciding between linear regression, logistic regression, naive Bayes, or neural networks.

Architecture of Neural Networks:

• Number of Layers and Neurons: Deciding the width (number of neurons) and depth (number of layers).
• Types of Layers: Whether to use LSTMs, convolutional layers, or dense layers.

Activation Functions:

They transform linear outputs into non-linear outputs. Popular choices include ReLU, tanh, and sigmoid, with ReLU being the default for most neural network layers.

Regularization and Optimization:

These influence the learning process. The use of L1/L2 regularization or dropout, as well as the type of optimizer (e.g., Adam, Adagrad), are hyperparameters.

Optimization Techniques

Techniques like grid search, random search, and Bayesian optimization are used to systematically explore combinations of hyperparameters to find the best configuration for a given task. While these methods can be computationally expensive, they are necessary for achieving optimal model performance.

Challenges and Future Directions

The field strives towards simplifying the choice of hyperparameters, ideally automating them to become parameters of the model itself. Efforts like Google's AutoML aim to handle hyperparameter tuning automatically.

Understanding and optimizing hyperparameters is a cornerstone in machine learning, directly impacting the effectiveness and efficiency of a model. Progress continues to integrate these choices into model training, reducing the dependency on human intervention and trial-and-error experimentation.

Decision Tree

• Model selection
  • Unsupervised? K-means Clustering => DL
  • Linear? Linear regression, logistic regression
  • Simple? Naive Bayes, Decision Tree (Random Forest, Gradient Boosting)
  • Little data? Boosting
  • Lots of data, complex situation? Deep learning
• Network
  • Layer arch
    • Vision? CNN
    • Time? LSTM
    • Other? MLP
    • Trading LSTM => CNN decision
  • Layer size design (funnel, etc)
    • Face pics
    • From BTC episode
    • Don't know? Layers=1, Neurons=mean(inputs, output) link
• Activations / nonlinearity
  • Output
    • Sigmoid = predict probability of output, usually at output
    • Softmax = multi-class
    • Nothing = regression
  • Relu family (Leaky Relu, Elu, Selu, ...) = vanishing gradient (gradient is constant), performance, usually better
  • Tanh = classification between two classes, mean 0 important

Try a walking desk to stay healthy while you study or work!

Ful notes and resources at ocdevel.com/mlg/26

NOTE. This episode is no longer relevant, and tforce_btc_trader no longer maintained. The current podcast project is Gnothi.

Episode Overview

TForce BTC Trader

• Project: Trading Crypto
  • Special: Intuitively highlights decisions: hypers, supervised v reinforcement, LSTM v CNN
• Crypto (v stock)
  • Bitcoin, Ethereum, Litecoin, Ripple
  • Many benefits (immutable permenant distributed ledger; security; low fees; international; etc)
  • For our purposes: popular, volatile, singular
    • Singular like Forex vs Stock (instruments)
• Trading basics
  • Day, swing, investing
  • Patterns (technical analysis, vs fundamentals)
  • OHLCV / Candles
  • Indicators
  • Exchanges & Arbitrage (GDAX, Krakken)
• Good because highlights lots
  • LSTM v CNN
  • Supervised v Reinforcement
  • Obvious net architectures (indicators, time-series, tanh v relu)

Episode Summary

The project "Bitcoin Trader" involves developing a Bitcoin trading bot using machine learning to capitalize on the hot topic of cryptocurrency and its potential profitability. The project will serve as a medium to delve into complex machine learning engineering topics, such as hyperparameter selection and reinforcement learning, over subsequent episodes.

Cryptocurrency, specifically Bitcoin, is used for its universal and decentralized nature, akin to a digital, secure, and democratic financial instrument like the US dollar. Bitcoin mining involves running complex calculations to manage the currency's existence, similar to a distributed Federal Reserve system, with transactions recorded on a secure and permanent ledger known as the blockchain.

The flexibility of cryptocurrency trading allows for machine learning applications across unsupervised, supervised, and reinforcement learning paradigms. This project will focus on using models such as LSTM recurrent neural networks and convolutional neural networks, highlighting Bitcoin's unique capacity to illustrate machine learning concept decisions like network architecture.

Trading differs from investing by focusing on profit from price fluctuations rather than a belief in long-term value increase. It involves understanding patterns in price actions to buy low and sell high. Different types of trading include day trading, which involves daily buying and selling, and swing trading, which spans longer periods.

Trading decisions rely on patterns identified in price graphs, using time series data. Data representation through candlesticks (OHLCV: open-high-low-close-volume), coupled with indicators like moving averages and RSI, provide multiple input features for machine learning models, enhancing prediction accuracy.

Exchanges like GDAX and Kraken serve as platforms for converting traditional currencies into cryptocurrencies. The efficient market hypothesis suggests that the value of an instrument is fairly priced based on the collective analysis of market participants. Differences in exchange prices can provide opportunities for arbitrage, further fueling trading strategies.

The project code, currently using deep reinforcement learning via tensor force, employs convolutional neural networks over LSTM to adapt to Bitcoin trading's intricacies. The project will be available at ocdevel.com for community engagement, with future episodes tackling hyperparameter selection and deep reinforcement learning techniques.

Try a walking desk to stay healthy while you study or work!

Notes and resources at ocdevel.com/mlg/25

• Filters and Feature Maps: Filters are small matrices used to detect visual features from an input image by applying them to local pixel patches, creating a 3D output called a feature map. Each filter is tasked with recognizing a specific pattern (e.g., edges, textures) in the input images.

• Convolutional Layers: The filter is applied across the image to produce an output which is the feature map. A convolutional layer is composed of several feature maps, with depth corresponding to the number of filters applied.

• Image Compression Techniques:

  • Window and Stride: The window is the size of the pixel patch examined by the filter, and stride determines how much the window moves over the image. Together, they allow compression of images by reducing the number of windows examined, effectively downsampling the image.
  • Padding: Padding allows the filter to account for border pixels that do not fit perfectly within the window size. 'Same' padding adds zero-padding to ensure all pixels are included, while 'valid' padding ignores excess pixels around the borders.

• Max Pooling: Max pooling is a downsampling technique used to reduce the spatial dimensions of feature maps by taking the maximum value over a defined window, further compressing and reducing computational load.

• Predefined Architectures: There are well-established predefined architectures like LeNet, AlexNet, and ResNet, which have been fine-tuned through competitions such as the ImageNet Challenge, and can be used directly or adapted for specific tasks in computer vision.