tags: [Web Development, Portfolio]

Over the past few days, I’ve embarked on a comprehensive redesign and improvement of my personal website. What started as a simple portfolio site has evolved into a fully-featured platform showcasing my projects, blog posts, and professional journey. This blog post hopes to document the design and technical decisions and lessons learned throughout the journey.

The Starting Point: Inspiration and Foundation

Drawing Inspiration from Sai’s Website

I initially took inspiration from Sai’s website, which is also built using the Urara template. However, while Sai’s site provided a solid foundation and aesthetic direction, I made significant changes to tailor the website to my own preferences and needs, which I will later discuss in detail.

Why Urara and SvelteKit?

I chose Urara as my foundation because:

1. Static site: Suitable for a simple blog/portfolio site
2. Markdown support: Useful for easy and clean blog posts
3. Tailwind CSS + DaisyUI: Rapid UI development with beautiful components

Design Decisions and Implementation

Before (2023) & After (2026)

Logging into my site in 2026, I felt it was outdated and aesthetically displeasing. I wanted to do something about this, but lacked the design or front-end skills necessary to make significant deviations from the boilerplate template. How did I overcome this? It’s simple, I began taking advantage of the AI capabilities of Cursor.

After countless hours of tinkering with new designs and features, I’m proud to showcase the significant strides my personal website has taken since its inception in 2023.

Homepage Layout Redesign

Hopefully, everyone agrees that the UI is significantly improved. To achieve the desired look, the homepage went through several iterations before settling on the final structure:

Final Layout:

1. Intro Section: Profile picture, personalized greeting (“Hi, I’m Daniel”), professional subtitle, and bio
2. Highlights: Quick-access cards for key professional pages (About Me, Projects, Resume)
3. Apps Section: Dedicated space for my created applications
4. Latest Posts: Grid of the four most recent blog posts

Key Design Choices:

• Spacing and Dividers: Added subtle horizontal dividers between sections to create visual separation without being too heavy
• Responsive Design: Ensured all sections work seamlessly on mobile and desktop
• Social Links Placement: Positioned “Say Hello” section with LinkedIn and GitHub icons

About Me Page: From Blog Post to Interactive Timeline

The About Me page transformation was one of the most significant changes:

Before: A simple markdown blog post
After: An interactive, tabbed timeline with three sections:

• Experience (default)
• Education
• Extracurriculars

Implementation Details:

• Each timeline entry is a card with:
  • Category badge (EXPERIENCE/EDUCATION/EXTRAS) in the top-right corner
  • Date range with primary color accent
  • Bold title for hierarchy
  • Description with bullets (») instead of standard list items
  • Adjusted text opacity (80% for descriptions) for better contrast

Why This Design?

• Better UX: Users can quickly filter by category
• Visual Hierarchy: Clear distinction between different types of experiences
• Professional Appearance: Timeline format is familiar and easy to scan
• Mobile-Friendly: Cards stack vertically on smaller screens

Projects Page: Modern Grid with Dual Actions

The projects page received a complete visual overhaul:

Before: A simple list of my projects with basic links
After: A grid layout with improved project cards featuring:

• Responsive 3-column grid (1 column on mobile, 3 on desktop)
• Project cards with images, titles, descriptions, and technology tags
• Action buttons: GitHub and “Try it out”
• Hover effects

Implementation Details:

• Each project card includes:
  • New project logo in a container
  • Title and description with proper typography hierarchy
  • Technology tag
  • Two action buttons at the bottom: GitHub and demo link
  • Hover effects: image zoom and title colour change to primary

Why This Design?

• Dual Actions: Users can either view the code (GitHub) or try the live demo, providing flexibility
• Visual Consistency: Cards match the overall site aesthetic with rounded corners and shadows
• Clear Hierarchy: Tags and buttons are clearly separated with adequate spacing for better readability

Feedback Form Development

Choosing the Right Solution

After receiving feedback from my roommate about the website’s usability, I realised there was still work to be done to make the site more intuitive. I needed a structured way to collect responses from friends and visitors to identify pain points and improvement opportunities. This led me to explore feedback form solutions that could be integrated into my website.

I explored several feedback form services, including Survicate, Usersnap, and Zoho Forms, but all required payment after trial periods. I ultimately settled on Tally.so. It’s free, offers easy integration with simple embed code, flexible form design, and no backend requirements as all submissions are handled by Tally.

Smart Timing and Implementation

One of the most important decisions was when to show the feedback prompt. The goal was to capture feedback from users who had actually explored the site, formed opinions, and genuinely cared about providing feedback. The challenge was balancing timing. Show it too early, and you get annoying, low-quality feedback; show it too late and users have already left.

I implemented an engagement-based system where the prompt only appears after all of these criteria are met:

1. Scroll Depth: User has scrolled at least 50% down on at least one page (tracked across page navigations)
2. Time on Site: User has been on the current page for at least 20 seconds
3. Page Views: User has visited at least 2 pages (homepage + another page)

Engagement metrics are tracked via localStorage to persist across page navigations. The prompt appears as a small card in the bottom-right corner that users can exit with an X button (won’t show again after dismissal). Once criteria are met, it fades in smoothly, and clicking “Share Feedback” opens the Tally pop-up form.

Technical Implementation: API Integration and Deployment

The NBA Position Predictor Integration

Motivation: One of the most interesting technical challenges was integrating my NBA Position Predictor application into the website. I had previously created a streamlit app, but it’s cold startup (running the app after prolonged downtime) took ~30 seconds. This was unacceptable.

I decided to reuse my ML models by building a FastAPI backend API and creating a new frontend design that integrates into my personal site. After initial tests, my NBA Position Predictor now takes less than 1 second.

Initial Approach: Embedding the streamlit applicaiton via <iframe>

• Rejected: Same loading issues as before and lack of design control

Final Approach: Native SvelteKit UI with separate FastAPI backend

• Benefits:
  • Full control over UI/UX
  • Better performance (~30 seconds -> ~0.5 seconds)
  • Seamless integration with site design

Implementation:

• Connected to an external FastAPI backend deployed at https://positionn-api.fly.dev. The code can be found in my positionn repo. FastAPI was chosen for its straightforward deployment process across most API hosting providers.
• Created /projects/positionn route with a custom SvelteKit page
• Two input modes: Player Statistics and Player Dimensions
• Client-side validation with range checking (e.g., 0-80 for points, 100-250cm for height)
• Info tooltips explaining valid ranges for each field

API Provider Journey: From Render to Fly.io

The backend deployment process then involved evaluating multiple hosting providers:

Render (Initial Choice)

• Pros:
  • Free
  • Simple deployment: auto-deploys with GitHub commits
• Cons:
  • Very slow cold starts (~50 seconds)
  • Costs ~$19/month for the API to run continually (i.e. no cold starts)

Fly.io (Final Choice)

• Pros:
  • Cost-Effective: ~$3/month for a 512MB RAM, 1 shared CPU instance
  • Low Cold Starts: ~0.8 seconds
  • Auto-Stop Configuration: Machines suspend when idle, saving money
  • Scalability: Easy to adjust resources (e.g., 256MB to 512MB RAM)
  • Simple Deployment: Command-line based, straightforward workflow
• Cons:
  • No auto-deploy: No auto-deployment with GitHub commits (at least I couldn’t find it)

Configuration Details:

toml
auto_stop_machines = suspend  # Saves money when idle. Not running 24/7.
min_machines_running = 0   # Can scale to zero
cpu_kind = "shared"        # Cost-optimised
cpus = 1                   # Adequate for ML model
memory_mb = 512            # Adequate for ML model

Trade-offs:

• ✅ Low cost (~$0.50-2/month with suspension of machines)
• ✅ Acceptable cold start time (~0.8 seconds)
• ❌ No automatic GitHub deployment (manual fly deploy required)
• ❌ Slightly more setup than fully managed platforms

Deployment Process:

1. Login: fly auth login
2. Launch: fly launch (uses existing fly.toml) - only for creating a new app for the first time
3. Deploy: Automatic or manual fly deploy - for deploying updates to an existing app
4. Monitor: fly logs and fly status

The manual deployment process, while not as seamless as GitHub, is straightforward enough that redeploying model improvements only takes a few terminal commands.

Development Challenges and Solutions

Theme Management: Preventing Flash

Problem: Theme would flash from dark to light on page loadRoot Cause: Theme was being set in JavaScript after the page load, causing a flash

Solution:

1. Added a blocking script in app.html that reads localStorage and sets data-theme synchronously in the <head>
2. Initialised theme state in the header component by reading the data-theme attribute

Multiple Page Component Conflicts

Problem: Multiple page component files found in src/routes/about_me : +page.svelte and +page.svelte.md Root Cause: Urara’s pnpm build was copying markdown files from urara/ to src/routes/, conflicting with manually created Svelte pagesSolution: Removed the source markdown file from urara/about_me/ to prevent conflicts

Image Path Management

Challenge: Non-consistent relative vs. absolute paths for images in markdown filesSolution: Used relative paths within each blog, ensuring images are copied correctly during the build process

The Software & Tools That Made It All Possible

Throughout this rebuild, I ended up touching far more tools and services than I initially expected, each playing a role somewhere between development, deployment, hosting, and user experience.

Here’s a concise summary of the stack involved in bringing my website to life. The important tools are bolded:

Frontend Framework & Theme

• SvelteKit + Urara Template — Core framework + blog/portfolio scaffolding
• Tailwind CSS + DaisyUI — Rapid UI development + pre-built components

Hosting, Domains & Deployment

• Vercel — Hosts the main static site (fast, free)
• Namecheap — Purchased the custom domain danielliu.xyz
• Fly.io — Deploys the FastAPI backend powering the NBA Position Predictor
• (Considered: Render — rejected due to slow cold starts and higher sustained cost)

Backend/API / ML

• Python + scikit-learn — For model training used in the Position Predictor
• FastAPI — Lightweight backend for ML inference
• Streamlit (original version) — Earlier iteration before moving to API architecture

Feedback & User Input

• Tally.so — Collects structured website feedback through an embedded form with pop-up UI
• (Considered: Survicate, Usersnap, Zoho — all require payment after trial or lacked business email to signup)

Version Control & Collaboration

• Git + GitHub — Source control and repo hosting

Design & Content Creation

• Cursor — AI-assisted development
• Canva — Created visuals for before/after comparisons and project previews

Key Learnings and Best Practices

1. Start with a Template, Customize Extensively

Using Urara as a foundation saved significant time, but the magic came from personalisation. Don’t be afraid to deviate from the template to match your vision.

2. Prioritise User Experience

Every design decision should consider:

• Mobile responsiveness: Test on multiple screen sizes
• Loading performance: Reduce running time and consider cost-tradeoffs
• Visual hierarchy: Clear distinction between content types

3. API Provider Selection Criteria

When choosing a hosting provider for APIs:

• Cold start time: Critical for user experience
• Cost: Balance between features and budget
• Ease of deployment: Consider your workflow preferences
• Scalability: Plan for future growth

4. Version Control and Deployment

• Git: Use feature branches for major changes
• Commit messages: Be descriptive about what changed and why. This comes in handy when developing over many years

Future Improvements

While the website is now fully functional, there are always opportunities for enhancement:

1. Performance Optimization:

   • Image optimization (compress and use responsive images for different screen sizes) and lazy loading (load images when they enter viewpoint to reduce initial page load time)

2. API Enhancements:

   • Add more applications
   • Implement caching strategies to reduce API response time. Repeated requests for identical inputs return cahced results

Conclusion

Building this personal website has been an incredibly rewarding experience. From initial inspiration to final deployment. The journey through different API providers, design iterations, and technical challenges has provided valuable insights that I’ll carry forward into future projects.

The website now serves as both a portfolio and summary of my professional journey. It’s a project that intend to evolve as I advance in my career.

If you’re building your own personal website, I hope this post provides some useful insights and inspiration.

While I could never become an NBA player myself, us data fanatics are fortunate there exists an abundance of rich basketball data. This opens up a world of interesting projects, with positionn serving as an app to predict your ideal NBA position and the players you most closely resemble.

This article provides a comprehensive overview of the process, learnings, and improvements from months of model development using machine learning techniques.

Step 1: Data Retrieval

The NBA API is a free-to-use Python package to access the APIs for NBA.com. Without going into too much detail, as it isn’t the premise of this article, I wrote a script that fetches and preprocesses player data between the 2015-2026 NBA seasons.

The data includes:

• Basic player statistics: points, rebounds, assists, steals, blocks etc, to build the model on.
• Player headshots: to display NBA players with similar statistics using their headshot images.

Step 2: Data preprocessing & feature engineering

While the NBA API provided high-quality data, there were a few notable issues which I remedied in the preprocessing notebook:

• My data retrieval script often crashed from the size of the dataset requests posted to the NBA API, forcing data retrieval in batches. I subsequently merged these batches in this stage of preprocessing.
• I computed commonly used advanced metrics, such as assist-to-turnover-ratio, stocks, and FIC, all of which are calculations formed from the basic statistics I already had.
• The assist-to-turnover-ratio had 20 observations with an Inf value. This occurs when the NBA player recorded 0 turnovers in a season, resulting in a division by 0, creating Inf values. These records were removed.

Step 3: Problem Definition

The objective of Positionn is to accurately predict the position (Guard, Forward, Center) a user would play based on their basic statistics. Using the retrieved and preprocessed data, we could train a model to assist us with this multi-class classification problem.

Before any training, I discovered the dataset was mildly imbalanced, with 1,781 Guards, 1476 Forwards, and 559 Centers. Since we want fair predictive performance across all classes, I decided to proceed using the following metrics for imbalanced datasets:

• Balanced accuracy: Averages how well the model correctly identifies each class, so rare classes count just as much as common ones.
• F1 macro: Computes the F1 score for each class independently (balancing precision and recall per class) and then takes the average. This treats all classes equally regardless of their frequency, making it suitable for imbalanced datasets.

Step 4: Feature Selection

To ensure the importance of player statistics in my dataset, I used the SelectKBest(), mutual_info_clasif(), and SelectKBest(score_func=chi2) methods to give a general score to each feature (see below).

• From the visualisations, I decided to prune out age and year. These were consistently the least important attributes across all three importance measures.

Step 5: Training & Comparing different models

To ensure a sufficient description of the major types of models I tried, I will separate the training process description into steps for the basic models and gradient boosting models.

Basic Models

The initial model in production, a support vector machine with gridsearch hyperparameter tuning, was the best performing model in terms of its nested cross-validation balanced accuracy and f1 scores. This was selected from a subset of model families which include:

• Logistic Regression
• Decision Tree
• Random Forest
• Histogram Gradient Boosting
• Support Vector Machine

To ensure a fair evaluation process, all models were trained using the same general process. I will now describe PlayerStatisticsModel, a class with the methods for training & evaluating these basic models.

First, I defined the initialisation of the PlayerStatisticsModel class.

class PlayerStatisticsModel:
    def __init__(
        self, model, preprocessor: ColumnTransformer,
        data: pd.DataFrame, target: pd.Series, cv: int
    ):
        """
         Initialisation of PlayerStatisticsModel class.
        
         Inputs:
          - model: sklearn machine learning model class
          - preprocessor (ColumnTransformer): preprocessing steps
          - data: input features
          - target: input target
          - cv: number of cv folds to estimate generalisability of model
        """
        self.metrics = ["balanced_accuracy", "f1_macro"]  # metrics to evaluate/fit models
        self.cv = cv  # number of cv folds
        self.results = pd.DataFrame()   # dataframe to store performance results of models
        self.data = data
        self.target = target
        self.X_train, self.X_test, self.y_train, self.y_test = train_test_split(data, target, test_size = 0.25, stratify=target, random_state=42)
        self.preprocessor = preprocessor
        self.model = Pipeline(
            steps=[
                ("preprocessor", preprocessor),
                ("model", model)
            ]
        )

• Notably, every model trained using the PlayerStatisticsModel class will use the same train/test split as we set random_state=42.
• The Scikit-Learn model passed to the class object, such as LogisticRegression() or DecisionTreeClassifier(), fits into the Pipeline(), with preprocessing (i.e. standard scaling) applied.

Next, I defined the .cv_score() method to run basic cross-validation on `self.model.

def cv_score(self, model_name: str) -> tuple[dict[list], dict[list]]:
    """
     Runs cross-validation on the default model (i.e. without hyperparameter tuning), obtaining the performance of the model.
     Inputs:
      - model_name (str): name of the model that will exist as its index in the self.results df
     Returns:
      - dict_scores_agg (dict[list]): dictionary containing the mean & std results for each model metric
      - dict_scores_folds (dict[list]): dictionary containing the model metric results for each fold
    """   
    # get CV scores for default model
    dict_scores_agg = dict()
    dict_scores_folds = dict()
    for metric in self.metrics:
        cv_results = cross_validate(self.model, data, target, cv=self.cv, scoring=metric)
        scoring = cv_results['test_score']
        dict_scores_agg[metric] = (scoring.mean(), scoring.std())
        dict_scores_folds[metric] = scoring
    self._add_model_results(dict_scores_agg, model_name)
    return dict_scores_agg, dict_scores_folds

• You will notice the results from each cross-validation fold is stored in dictionaries dict_scores_agg and dict_scores_folds. These store the average and fold-specific balanced accuracy and f1 scores of the model.
• The results are then added to a record of different model performances by calling the self._add_model_results() helper function.

Since we will continue to use self._add_model_results() helper method, let’s formally define it.

def _add_model_results(self, model_result: dict[list], model_name: str):
    """
     Anonymous method that concatenates the mean and standard deviation cross-validation score for all specified metrics of a model onto a 
     pre-existing dataframe (self.results). This enables us to quickly
     compare the cv-performance of models as we build them.
     Inputs:
      - model_result (dict[list]): dictionary containing the mean & std results for each model metric
      - model_name (str): name of the model that will exist as its index in the self.results df
    """   
    # Gets model results as df to append to self.results
    df = pd.DataFrame(model_result)
    # extract rows and add suffixes to column names, then combine
    mean_row = df.iloc[0].rename(lambda col: f"{col}_mean")
    std_row = df.iloc[1].rename(lambda col: f"{col}_std")
    flattened_series = pd.concat([mean_row, std_row])
    flattened_df = pd.DataFrame([flattened_series])
    # set the index to the model name
    flattened_df.index = [model_name]
    # if model already exists in results df, then replace. Otherwise, append.
    if model_name in list(self.results.index):
        self.results.loc[model_name] = flattened_df.iloc[0]
    else:
        self.results = pd.concat([self.results, flattened_df])

• This helper method appends the mean and standard deviation balanced accuracy and f1 cross-validation scores to self.results, a dataframe to quickly compare the cv performance of models as we build them.

We define another convenience method, .print_cv_results(), which prints the mean and standard deviation cross-validation score in a pretty format.

def print_cv_results(self, dict_results:dict[tuple]):
    """
     Prints the mean and standard deviation cross-validation score for a specified metrics in a pretty format.
    
     Inputs:
      - dict_results (dict[tuple]): the mean & std results of a model on all evaluation metrics
    """
    for metric, value in dict_results.items():
        print(f"The mean cross-validation {metric} score is: "
        f"{value[0]:.3f} ± {value[1]:.3f}")

Next, we define a general method .grid_search_cv_score() to fit and tune a models hyperparameters with gridsearch, performing nested cross-validation to estimate its balanced accuracy and f1 on unseen data.

def grid_search_cv_score(self, model_name: str, param_grid: dict):
    """
     Fits a model with grid_search to tune its hyperparameters. Then performs
     nested cross-validation to obtain an estimate of the generalisability
     of the model & variance of this estimate.
     Inputs:
      - model_name (str): name of the model that will exist as its index in the self.results df
      - param_grid (dict): grid of hyperparameters to iterate through
     
     Returns:
      - dict_scores_agg (dict[list]): dictionary containing the mean & std results for each model metric
      - dict_scores_folds (dict[list]): dictionary containing the model metric results for each fold
      - best_model: sklearn model of best performing model after gridsearch hyperparameter tuning
    """
    with self._suppress_warnings_and_output():
        model_grid_search = GridSearchCV(self.model, param_grid=param_grid, n_jobs=-1, scoring=self.metrics, refit=self.metrics[0], verbose=1)
        # fit grid search on training data to extract best model
        model_grid_search.fit(self.X_train, self.y_train)
        best_model = model_grid_search.best_estimator_
        # get nested CV scores for best model
        dict_scores_agg = dict()
        dict_scores_folds = dict()
        # perform nested cv for each metric, storing results in dictionaries
        for metric in self.metrics:
            cv_results = cross_validate(model_grid_search, data, target, cv=self.cv, n_jobs=-1, scoring=metric)
            scoring = cv_results['test_score']
            dict_scores_agg[metric] = (scoring.mean(), scoring.std())
            dict_scores_folds[metric] = scoring
        # add results to dataframe for easy model comparison
        self._add_model_results(dict_scores_agg, model_name)
        return dict_scores_agg, dict_scores_folds, best_model

• The method requires param_grid, a grid of hyperparameter values to try on the model.
• Only the best performing model will have its performance and pipeline model returned.

Similarly, we define a general method .randomised_search_cv_score() to fit and tune a models hyperparameters with randomsearch, performing nested cross-validation to estimate its balanced accuracy and f1 on unseen data.

def randomised_search_cv_score(self, model_name: str, param_distributions: dict, n_iter: int):
    """
     Fits a model with randomised_search to tune its hyperparameters.
     It Then performs nested cross-validation to obtain an estimate of the 
     generalisability of the model & variance of this estimate.
     Inputs:
      - model_name (str): name of the model that will exist as its index in the self.results df
      - param_distributions (dict): range of possible values each hyperparameter that can be sampled
      - n_iter (int): number of iterations to run randomised_search (i.e. models to be fitted & evaluated)
     
     Returns:
      - dict_scores_agg (dict[list]): dictionary containing the mean & std results for each model metric
      - dict_scores_folds (dict[list]): dictionary containing the model metric results for each fold
      - best_model: sklearn model of best performing model after gridsearch hyperparameter tuning
    """
    with self._suppress_warnings_and_output():
        model_random_search = RandomizedSearchCV(self.model, param_distributions=param_distributions, n_iter=n_iter, n_jobs=-1, scoring=self.metrics, refit=self.metrics[0], verbose=1)
        # fit grid search on training data to extract best model
        model_random_search.fit(self.X_train, self.y_train)
        best_model = model_random_search.best_estimator_
        # get nested CV scores for best model
        dict_scores_agg = dict()
        dict_scores_folds = dict()
        # perform nested cv for each metric, storing results in dictionaries
        for metric in self.metrics:
            cv_results = cross_validate(model_random_search, data, target, cv=self.cv, n_jobs=-1, scoring=metric)
            scoring = cv_results['test_score']
            dict_scores_agg[metric] = (scoring.mean(), scoring.std())
            dict_scores_folds[metric] = scoring
        # add results to dataframe for easy model comparison    
        self._add_model_results(dict_scores_agg, model_name)
        return dict_scores_agg, dict_scores_folds, best_model

• The method requires param_distributions, a range of hyperparameter values to try on the model.

What is the difference between grid search and randomised search?

• Answer question to explain rationale!

Why do we need nested cross-validation for evaluating and selection of models when performing hyperparameter tuning?

• Answer question to explain rationale!

While we returned the performance and tuned model itself, the gridsearch and randomised search methods did not provide us with the tuned hyperparameters themselves. The .get_best_tuned_params() method provides this desired functionality.

def get_best_tuned_params(self, best_model, param_grid: dict):
    """
     Gets the best tuned parameters for a model after gridsearch
     or randomised_search hyperparameter tuning.
     Inputs:
      - best_model: sklearn model of best performing model after hyperparameter tuning
      - param_grid (dict): grid of hyperparameters to iterate through
     
     Returns:
      - dictionary of tuned parameters and their values for the best model
    """
    params = [param for param in best_model.get_params() if param.startswith('model__') and param in list(param_grid.keys())]
    params_values = [best_model.get_params()[param] for param in params]
    return dict(zip(params, params_values))

In some ad-hoc instances, I was interested in reinforced the superiority of a model by comparing the individual fold performance between two models, plotting their balanced accuracy and f1 scores. The .plot_fold_comparison() method does this.

def plot_fold_comparison(self, metric: str, fold_results: tuple[list[int]], label_names: tuple[str], colors: tuple[str]):
    """
     Plots a comparison of the model's evaluation metric (i.e. performance)
     on each individual cross-validation fold. If there are 4
     cross-validation folds, a scatterplot with four dots will be plotted.
    
     Inputs:
      - metric (str): sklearn evaluation metric of choice
      - fold_results (tuple[list[int]]): tuple containing the fold results of each model
      - label_names (tuple[str]): names to give each to each model in the legend of plot
      - colors (tuple[str]): colors to give each model in the plot
    """
    # handle edge case: user passes in invalid metric to plot
    if metric not in self.metrics:
        raise Exception(f"Please pass in a valid metric: {self.metrics}")
    else:
        fig, ax = plt.subplots(figsize=(6, 5))
        # iterate through each model's fold_result, adding scatterplots
        for i in range(len(fold_results)):
            indicies = np.arange(len(fold_results[i][metric]))
            sns.scatterplot(x=indicies, y=fold_results[i][metric], color=f"tab:{colors[i]}", label=label_names[i], ax=ax)
        # plot axis settings
        ax.set_xlabel("Cross-validation iteration")
        ax.set_ylabel("Balanced Accuracy")
        ax.set_title(f"{self.cv}-Fold {metric}")
        ax.set_xticks(np.arange(0, self.cv))
        ax.set_ylim(0,1)
        ax.legend(bbox_to_anchor=(1.05, 1), loc="upper left")

For instance, we used this method to visualise a comparison between the cross-validation folds of the best performing logistic regression and tree models.

• Insert image here!!! (— Comparison of folds between best Logistic Regression & Decision Tree models —)

Mostly, this method was not extremely useful.

Finally, you may have noticed I used the ._suppress_warnings_and_output() helper method throughout the previous methods. Its purpose is to suppress annoying output warning messages from running gridsearch or randomised search.

@contextmanager
def _suppress_warnings_and_output(self):
    # save original warning environment variable
    original_warnings = os.environ.get("PYTHONWARNINGS", "")
    
    # suppress UserWarning and FutureWarning
    os.environ["PYTHONWARNINGS"] = "ignore::UserWarning, ignore::FutureWarning"
    warnings.filterwarnings("ignore", category=UserWarning)
    warnings.filterwarnings("ignore", category=FutureWarning)
    # capture all stdout/stderr output
    with io.capture_output() as captured:
        try:
            yield captured
        finally:
            # restore warnings environment and filters
            os.environ["PYTHONWARNINGS"] = original_warnings
            warnings.filterwarnings("default", category=UserWarning)
            warnings.filterwarnings("default", category=FutureWarning)

Continue describing how I used these methods to train a single model. Provide an example (e.g. LogisticRegression).

Show the end result after model training. (i.e. the final table). One thing that catches my eye is that both Gradient Boosting methods outperformed any of the basic methods. So how did we go back Gradient Boosting (the final models in production after I found they outperformed svms; mention how they were a late addition).

Gradient Boosting Models

Note: Big Mistake: Training on player_id. Forced me to re-run my entire workflow and assess whether any model rankings changed. LGBM still remained best model.

This article provides my comprehensive overview of XGBoost; the algorithm and package in Python.

Ensemble Learning

Ensemble learning is a technique that combines multiple individual models, aggregating their predictions, to produce better predictions than a single model alone. XGBoost is a form of ensemble-based learning, so it feels natural to begin by describing this effective method of building models. common ensemble-based methods are bagging and boosting.

Bagging (Boostrap Aggregating)

Bagging involves training the same model on multiple bootstrap samples (i.e., randomly sampled with replacement from the training data). This produces several individual models, each trained on variations of the training set. The final prediction is the aggregate of the individual model predictions - usually their average (for regression) and majority (for classification).

Boosting

Boosting is a sequential ensemble method where ‘weak’ models are trained one after another. Each new model focuses on the errors made by the previous models, placing greater weight on examples that were previous mispredicted. This ensures the ensemble incrementally improves its performance as more models are added. The final predictor is the weighted sum of all ‘weak’ models - not just the last one.

Bagging vs Boosting

History of Boosting

AdaBoost

We begin the Boosting story with AdaBoost, where misclassified samples are assigned higher weights for the next model, so the next model pays more attention to them. This idea doesn’t generalise well to common scenarios nowadays; regression, arbitrary loss, or sparse data.

Gradient Boosting

Instead of simply reweighting samples to focus on mistakes, Gradient Boosting reframes AdaBoost as an optimisation problem. Rather than having each iterative model predict the target directly, each new tree predicts the residuals (mistakes) of the current ensemble’s predictions.

Example: House price prediction

As a starting point, suppose the model predicts the same value for every house, say $350k. The true prices might be:

• y = [$200k, $300k, $400k, $500k]

Then the initial predictions are:

• y_hat = [$350k, $350k, $350k, $350k]

and the initial residuals are:

• r_i = y_i - y_hat_i = [$-150k, $-50k, $+50k, $+150k]

These residuals represent what the current model has failed to explain. Under squared error loss, they are also equal to the negative gradient of the loss with respect to the predictions.

For squared error, the loss for a single sample is:

• L(y, y_hat) = 0.5 * (y - y_hat)^2

If you take the derivative of this with respect to y_hat, you get:

• dL/dy_hat = (y_hat - y)

The negative gradient is therefore the residual:

• -(dL/dy_hat) = y - y_hat = r_i

So when Gradient Boosting trains the next weak model (usually a shallow tree), it does **not train it on the original house prices y. Instead:

• The features (e.g. bedrooms, size, suburb) stay the same.
• The targets become the residuals r_i.

We’re no longer predicting the full price. We’re predicting corrections that tell us how far our existing model is from a perfect one.

After training this tree h_1(x), we update the model:

• F_1(x) = F_0(x) + η * h_1(x)

where η (eta) is the learning rate. Because h_1(x) approximates the negative gradient (the direction of steepest descent), adding it reduces the loss.

Gradient Boosting repeats this process:

1. Compute residuals r_i = y_i - F_{m-1}(x_i) (for squared loss; more generally, use negative gradients).
2. Fit a shallow tree h_m(x) to (x_i, r_i).
3. Update the model: F_m(x) = F_{m-1}(x) + η * h_m(x).

Each tree is a small correction step in the direction that most reduces the loss. This is mathematically the same idea as gradient descent, except instead of updating weights directly (like in a neural network), Gradient Boosting updates the function itself by adding trees.

Analogy

Think of writing an essay and getting feedback:

1. You write a first draft (initial model).
2. The teacher marks mistakes and comments (these are like residuals).
3. You fix only those mistakes (fit a model to the residuals).
4. You submit again and get a new set of corrections.
5. You fix those and repeat.

You don’t rewrite the entire essay from scratch each time — you only correct what remains wrong. After enough rounds of focused corrections, the essay becomes strong.

Gradient Boosting works the same way: each tree is a small correction pass over the current model. Individually, the trees are weak, but together they form a powerful predictor.

eXtreme Gradient Boosting (XGBoost)

XGBoost is an industry-favourite for its speed, scalability, and flexibility. It extends on the classic Gradient Boosting idea of having each new tree predict the residuals (mistakes) of the current ensemble’s predictions with the following:

• Reguluarisation
• Optimisation
• Flexibility

Here is an excellent article that describe XGBoost under-the-hood.

Here is another article that details practical applications of XGBoost and Optuna for hyperparameter tuning.

There is nothing here yet!

There is nothing here yet!

The journey

How did I end up at Canva?

A bit of background. Canva had always been one of my dream companies for a few reasons:

• I had been using Canva for a long time. In fact, it shocked me that I had been using Canva since year 10 to create stunning infographic designs. I always knew of the product and loved using it, but it never registered that the product was named Canva, and that it was a major technology employer based in Australia until I applied.
• A couple of Canva employees showed up at an uni club trivia night I attended during my first year. One question was: ‘where was Canva founded?’ I blindly guessed Perth, and somehow got it right. Ever since then, I had been enamoured by Canva. Perhaps it was the inspiration that came with seeing an amazing product originate from own hometown.

So without hesitation, I applied. It was a longshot. I knew just how competitive it would be. In fact, I later found out that just 89 interns were taken from a pool of ~ 7000 applicants. But after an online assessment and a technical plus behavioural interview, I had made it in.

Week 1 - Onboarding

Onboarding week swiftly came and went. We were taken through ample modules and setup the software necessary for our projects (e.g. Snowflake, GitHub, Accessing Data Warehouse). I also met my support team - including my host, co-host and buddy - who were all super smart & lovely people, and discussed my intern project with my host!

All the interns spent the first week from the comfort of their home (or closest office), which meant that I explored the amazing Melbourne office. A small, cosy and humble abode in the heart of Collingwood, the Melbourne office had delicious breakfast and lunched served up by the chefs, a friendly vibe team who greeted you every morning, great background music, free merch at the swag station and sick artwork fit for a design company.

Week 2 - Campus week

Campus week was when the fun really began - especially since I was sick during week 1. All the interns were flown to Sydney and given accommodation for a week, which meant some of us (myself included) got to meet our team in person, there were plenty of intern activities planned and we capped off the week with the annual Canva end-of-year party!

Let me tell you, the party was amazing. There was plenty of music (including a dance floor) to keep the vibes high, the street was decked out for us with food trucks, we attended stand-up comedy, learned how to shoot arrows and bonded over alcohol on the rooftop. Actually, we could’ve gotten drunk anytime with beer taps and alcohol readily available on the Sydney office rooftop.

I’m going to be completely transparent. I didn’t get much work done this week. There were just too many intern events - both during and outside of work hours - that I didn’t find the time to fully concentrate on my intern project. Fortunately, my team had told me to enjoy myself this week and not worry too much about work.

Weeks 3 to 8 - Sydney

I decided to stay in Sydney for a few extra weeks - even after the all-expenses-paid Campus Week had wrapped up. My reasoning? I felt there was so much more Syndey could offer professionally and socially. I was fortunate in both of these aspects.

Professionally, most of the product Data Scientists were located in Sydney including my host, co-host and buddy. This meant that I could better connect with my team and learn a heck of a lot more (scroll down to find my key learnings). In fact, those two months felt jam-packed with personal milestones that I could celebrate with the team - including an engagement, baby announcement and permanent residency approval! Even though I wish I could’ve seen my team a bit more - many came in just once a week - I totally get why, and I still had an amazing time with them.

Even though I wish I could’ve seen my team a bit more as many came in just once a week, I totally get why they couldn’t come in more often and still had an amazing time with them. Plus, I had my buddy next to me four days a week!

Socially, Sydney had more people. Especially interns. While I do wish I had taken the opportunity to mingle with more interns, I truly feel blessed to have gotten close to some amazing ones - especially those that also relocated from other states & stayed at Iglu accommodation. We would regularly explore the many wonders of Sydney (Bondi beach, Harbour bridge, Opera House, Manly etc), play games (Exploding Kitten, Codenames, Switch) and work together. I never felt there was a second to spare as some activity had always been planned for the weekend.

Canva clubs were also a major highlight. You were allowed to attend up to four club-sponsored events each month, which meant the entire experience would be on the house! I was able to try out new activities like pilates (with my team) and pickleball, and indulge in treats like yo-chi, all for the price of … NOTHING! Who doesn’t love free stuff, all the while feeling part of a community :o

Weeks 9 to 11 - Melbourne

The palpable sorrow felt from leaving all of my amazing friends and team in Sydney started to hit my first day back. Although I had been to the Melbourne office once prior, I never realised just how difficult it was to commute to from my house (~ 1hr 15 mins). In spite of this, my experience back in Melbourne was much the same.

I had made significant progress on my project - receiving positive feedback from key stakeholders and collaborating with a PM on a new feature that came from my report, and was set for experimentation. Safe to say, the last couple of weeks were extremely busy for everyone.

Immersing myself into the Melbourne office culture wasn’t too difficult. Though, there were only around 10 interns and with everyone working overtime, it was difficult to organise many social outings. You wouldn’t believe the crazy hours some interns pulled. Alas, I knew when I worked best and prioritised waking up feeling refreshed.

Despite less social events, I still had a great time. I was able to meet a few teammates who were based out of Melbourne - even finding out one of them came from Perth aswell! We organised pickleball and basketball amongst the interns during these final few weeks, and enjoyed the lovely food (arguably better than Sydney’s) made in-house by the chefs. I would also describe general vibe among the Melbourne office as more ‘cosy’ - chill music playing, a closer-knit community and physical proximity all contributed to this change of scenery.

Week 12 - Presentations

The juxtaposition of the final week to the first week was immense. The last push to finish our work, submit our personal reflections & presentations and mingle with our peers one last time meant there was little time for much else. The Data Science interns gave a presentation among most Data Scientists at Canva at the start of the week, and all interns gave their final intern presentation on Wednesday and Thursday. Being in product, I was given the opportunity to present 1st among all Data Scientists and 2nd among all 89 interns. It was quite the double-edged sword. On the one hand, I would be free from comparison prior to my presentation and would have the most crowd engagement (lots of interns shouting their support in the chat). On the other hand, since our presentations were broadcasted to the entire company, I would have the most eyes on me (which is also kind of good).

My presentations went well as I received positive feedback all around. However, comparison being the thief of joy that it is - it was hard not to compare my work to other interns (especially Data Scientists). For whatever reason, I felt that my work didn’t sound as ‘impactful’ or ‘cool’ as other interns - which was probably not true - and found myself always comparing. Reflecting back, it’s good to appreciate the amazing work other’s do but don’t forget all the work you’ve put in to deliver your best go at a challenging problem.

Week 12 - Final day

After the stress that came with presentations, it was time to wind down and relax on the final day. I said my goodbyes to everyone - especially my team - expressing my gratitude for the impact that so many Canvanauts had on my career. In particular, my coach/host. I could not have asked for a better host and felt genuinely sad that I wouldn’t be working alongside him anymore. He always gave my credit - giving me many kudos on Canvaworld - and made sure that everything was okay personally before getting into any work-related topics. He even organised a suprise final meeting with all the product Data Scientists where they gave me four cans of berry jam (berries are my favourite fruit), a basketball book (I love basketball) and some berry tea.

There is honestly too much that went on during this final week to describe in depth and so I may have missed some details.

Final remarks

A few months have passed and the dust has settled on the internship. I’m back at university now - completing an industry placement - but can’t help myself from reminiscing on the wonderful 12-week experience I had over the summer. Although we all received our decision calls regarding return offers, and most interns didn’t recieve one (including myself), I still feel as if I can walk away proud of everything I achieved and all the memories I created.

Learnings

Here are a couple of key learnings that I hope to apply at my upcoming graduate role.

1. Quantifying impact is difficult as a Data Scientist, so be proactive and setup regular meetings with stakeholders to discuss the impact of your work. However, make the meeting all about you, and how you can quantify your impact. A better use of both parties’ time would be to use the meeting to discuss quantitative insights you’ve found and how they may be used (e.g. new feature ideas, modifications to existing features). Always follow up with estimated timelines of any new ideas proposed by the other party. For example, I was able to quantify the impact of my research report by hosting a meeting with a product manager, who discussed their new feature idea that my research supported.

2. Always ask ‘so what’? So what is the impact of the insight? So what is its important? So what can we do about it? These questions are now what I will call the three ‘so whats’ - which if kept in the forefront of your mind, will keep you on track. While I’m gaining business acumen, it may be difficult to see the big picture, or to tie an insight to some impactful action (what can we do about it?). To remedy this, ask around. Propose the idea to your manager, teammates, and product managers to pick their brain on the insight to see whether it’s truly relevant, and can not only be impactful, but deliver feasible business results.

3. Get to know EVERYONE in your team by setting up coffee catchups. This is definitely one area of improvement. At the conclusion of my internship, I felt comfortable asking for advice from the few teammates I regularly interacted with on the project, but I knew I had missed a major opportunity by not getting to know everyone in my team (atleast) better from the start. First impressions are key. Being proactive in setting up coffee catchups to get to know others personally and showing curiosity in their work/roles will help me to feel more welcome (it’s really up to me to feel part the team), and have more avenues for support. Seeing other interns (especially Viv) network has really inspired me to do the same.

4. Come prepared for important meetings with an agenda. This is one area I did well in. I had a continuous agenda doc that I would prepopulate with topics that I wanted to cover in all my one-on-ones with my manager. The agenda doc wasn’t complicated - simply a table with dot-points. I also found that creating and sharing an agenda for important meetings with stakeholders (e.g. product managers), with topics and ideas to already there to discuss really helped in facilitating the conversation. Preparing in this way for my meeting with the AI product manager, and asking my coach to review the agenda helped to demonstrate my professionalism and come out of the meeting with something valuable. Remember, people are busy, so make the most of the meeting by coming prepared.

5. Set expectations with your manager early. Inevitably, you will go through a formal performance review. To position yourself for success, ensure your first few meetings establish both parties expectation and interpretation of your growth profiles. Moreover, regular conversations with not just your manager, but other senior employees in the same field are so important for understanding how to perform above and beyond expectations. I would recommend setting aside at least a bi-weekly meeting to discuss your performance, career aspirations, and establish a plan to achieving these goals. This might include “completing project X”.

6. Keep yourself informed about the internals of the company. Upon reflection, I regrettably feel as if I had not paid enough attention to keeping up-to date with internal business developments/projects. Moving forward, I intend to give my undivided attention to town halls, read trending confluence pages, and develop greater business awareness to ensure I can tie my work back to OKRs (Objectives and Key Results) when completing my performance review.

7. Create a brag book. Towards the end of my internship, a teammate advised me to create a book/spreadsheet of all my accomplishments and their impact. While I hadn’t maintained one throughout my internship, I undoubtedly see immense value in doing so - especially when completing performance reviews. Moving forward, I intend to adopt an online template that documents all my professional achievements and tasks, no matter how little.

8. Develop your product sense; regularly use and actively learn about the products of your company. This is an area I excelled in which paid dividends. Embedded in the Canva Docs team, I dedicated myself to learning about the product, leading to a strong product sense and understanding of how our users might engage with it. For instance, I discovered an AI feature was of the upmost importnance for user engagement. Moving forward with this mindset of curiosity will be essential as I look to work as a product Data Scientist in the future.

9. Meaningful project names matter, especially as you must become your strongest proponent to have a successful career in Data Science. Pitch your work, sell its importance and increase your visibility. What’s the point in doing work if no-one uses it, sees its value, or remembers it? My coach always comes up with a catchy project name that people will remember and could associate to an idea. After tossing around some ideas with my team, I named my project ‘Sweet Suite Adoption’ - a nod to both the ‘sweet’ Canva suite and its goal: improving user adoption of those products.

Summer Holidays (Nov-Feb)

After a gruelling first year of university and having just completed exams, I immediately flew back home to Perth in order to be with my family and close friends. Throughout this time back in Perth there were two major tasks I aimed to accomplish.

R

In line with my goal of learning a new language every holiday, these holidays saw me learn the basics of R with a focus on the all-encompassing tidyverse package. I was able to go through the R for Data Science book and discovered a hidden gem of a youtube channel in Kelsey Gonzalez, a lead data scientist at IBM who taught the tidyverse package at American University which enabled me to quickly learn the language.

Internship Hunt

It’s common knowledge that recruiters prefer penultimate year students because they have the ability to start work only a year following the internship. Having just finished my first year, I was aware of the struggles I would encounter whilst searching for an internship but perhaps was not prepared for the amount of rejections I would recieve. Interview after Interview, Rejection after Rejection. It seemed like an endless cycle that was frankly causing me a lot of stress. However, after getting through an initial resume screening, phone interview, assessment centre and final video interview, I was fortunate to land an internship as a Data Analytics intern at Major Road Projects Victoria (MRPV) during these holidays. It goes without saying, I was ecastic.

Semester 1 (Feb-Jun)

Major Road Projects Victoria

My internship began in January and would run till July which meant I would be working part-time (3 days a week) during semester 1 of my second year. Initially, this was quite the load to manage but as slowly I became more and more comfortable in my work and started thoroughly enjoying the routine I had established. My work at MRPV was simple, complete weekly/monthly tasks in Excel and find areas in our processes to automate using Python. Although the work was quite slow given it was a government organisation, the memories that I made and experiences I took away from my first ever job will forever stay with me.

Some of my personal favourite experiences included:

• Going a tour of the Essendon Fields construction site and having the ability to socialise for an extended period with a lot of the engineering interns. Infact, I still hang out with one of the interns I met during this site tour nearly 6 months after the end of my internship.
• A new advisor joining our team. Two months into my internship, our team added another advisor which I found to be one of the best things that happened because he often worked the same days I was in office and we were able to talk about almost anything from tech, career aspirations and even history.

CCA Sponsorship Officer

Throughout semester 1, I was one of six sponsorship officers in the Computing Commerce Association (CCA) helping to attract and maintain relationships with companies who provide services or products relating to Computing and/or Commerce. The workload in this role was more than manageable and I’d highly encourage anyone looking to dip their toes into university clubs to try out a sponsorship team in order to gauge the atmosphere of a club whilst having relatively little commitment in terms of club work throughout the semester (if that’s what you’re after).

Units

I will attempt to provide a more comprehensive review of all FIT (Faculty of IT) units in a future blog post but for now I would like leave my two cents on the units I took in semester 1 of 2023:

• Intro to computer systems, networks and security (FIT1047): This is a good unit introductory unit run by tutors that I find genuinely care about your learning. As a double degree student who took FIT1008 in the prior semester where we learnt MIPS, the content in FIT1047 was much simpler with MARIE and Logisim used to understand the fundamentals of computer systems, Wireshark for networking and cybersecurity. Overall, I found it not awfully challenging but I suspect first years taking this unit in their first semester might have had a different experience if they had no prior knowledge of computer architecture.
• Intro to data analysis (ETC1010): I found this unit enjoyable, especially given it is effectively a unit that teaches the basics of R (which I learnt over the holidays). I found some of the assignment and examination questions a bit ambiguous and littered with spelling mistakes but overall, the unit was enjoyable and quite easy.
• Algorithms and data structures (FIT2004): The infamous FIT2004… An essential unit needed by any good programmer which really stretches your thinking cap and expects you to fail ALOT. Proficiency in Python is expected and no effort will be made to teach you any Python. I was personally very challenged by this unit as it introduces a new bucket of problems to solve and definitely is a problem solving class. In saying this, I found it really rewarding and was still able to barely manage a HD by dedicating countless hours every week solving all the tutorial problems, asking a plethora of questions and starting the assignments as soon as they were released.

Winter Holidays (Jun-Jul)

NYK Failure Project

As an avid NBA and New York Knicks fan, I’ve been pondering my life choices over the past 8 years watching the Knicks play. Following our relative success over the past 2 seasons, I was inspired to take a dive into what has made us such a horrible NBA team over the past decade which can be found through my report here.

In order to build this report, I spent close to a month obtaining NBA data through web scraping/APIs, wrangling the data using R, uncovering patterns in the data and building meaningful visualisations using the beautiful ggplot2. I often failed and restarted through the inability to find anything worthwhile to talk about or struggling to tidy the data into a format I could use. I restarted about 3 times and had to spend countless hours procuring the internet for suitable datasets which I eventually found through Sportrac and the NBA API.

In the end, I was very happy with the report that I had built as my first beginner project with hopefully bigger things ahead in the future.

CCA Retreat

The CCA committee took on Phillip Island as roughly 20 of us looked to enjoy a weekend of action packed fun. We started by meeting up at Monash University before heading off to Pings Dumpling (highly recommend) for lunch. Then we departed for our accomodation in Phillip Island where most of us stayed up and played card games, walked along the beach where we saw actual shooting stars and talked all night. The next day was even more action packed as some of us went bouldering, some baked cakes and some enjoyed cooking dinner which fortunately for everyone else, I didn’t participate in. That night I got about an hour of sleep as we talked about life before I had to drive home the next morning. For many of us, this was the first time we were able to talk for an extended period with many of our fellow committee members which really built a stronger and more tight knit committee.

Semester 2 (Jul-Nov)

Internship Hunt v2

As my internship at MRPV came to a close and a majority of companies began opening up applications for their summer internship programs, once again I began seeking an opportunity to taste more real world experience. This time I was eligible for a lot more internships and applied to roughly 40 places, from which I was fortunate to land an offer from Newcrest Mining as a Data Science intern. It felt surreal as this company and position was at the top of my list of those roughly 40 companies I applied for.

Throughout this process, the many rejections taught me a great deal. Firstly, I definitely need to work on my technical interviews through practicing relevant technical and non-technical interview questions with a particular focus on data science questions. Secondly, a particular weakness of mine is psychometric tests which I will certainly need to work on through UCAT resources. Finally, I will need to add to my resume throughout next year as a majority of the places rejected me during the initial resume screening.

CCA Treasurer

In September of this year I ran for the position of Treasurer in CCA. This was a position that I had long desired because of my interest in managing finances and for the ability to be in a ‘top 4’ position in a university club which would afford me the opportunity to leave a significant impact on one of the largest university clubs. So far the executive team for 2023/2024 has been amazing with everyone genuinely seeming passionate about bringing new, innovative ideas to further develop our club.

Units

In semester 2 I went back to a normal load with what I considered to be a moderately difficult semester in terms of the units I took. Lets have a look at what I thought of each unit I took this semester.

• Databases (FIT2094): Personally I loved this unit, especially in the second half when we were finished with database design and moved onto database queries using SQL. I found it truely enjoyable to work on the assignments, especially considering the teaching staff were all so friendly and quick to help. A major bonus of this unit is that it’s highly practical with no exam!
• Introduction to data science (FIT1043): FIT1043 is widely recognised as an ‘easy’ unit with my tutor even complaining about how easy this unit is. It should come as no surprise that I found this unit enjoyable as it not only covered the basics of machine learning including regression, classification and clustering but also as a much needed non time-consuming unit.
• Statistical Thinking (ETC2420): This unit is essential in that it unlocks machine learning units that have it as a pre-requisite which made me take it as soon as possible. The content itself was difficult to comprehend at times, especially Bayesian analysis but I found it highly rewarding when I eventually grasped the concepts through lots of well … thinking. The name of the unit really resonates when you take this unit as you need to really ‘think’ of how to interpret the data given the statistical concepts taught including permutation tests, bootstrapping, bayesian inference, maximum likelihood estimation and more!
• Introductory econometrics (ETC2410): I found this unit challenging not because of the concepts but rather the sheer quantity of content that was covered. I enjoyed learning hypothesis testing, quadratic regression, autocorrelation, heteroskedasticity and time series analysis but the amount of notes I took was absurd. In the end the exam was much easier than anticipated and I felt the teaching staff did a good job of preparing us for the final exam. As a core unit for both Econometrics and Finance majors, I can definitely see the necessity in taking this unit.

Concluding Remarks

There is a lot more to my year than what was mentioned such as my experiences volunteering at Monash Open Day or the Melbourne United Basketball Club but I thought that I’d bring to light some of my most memorable moments, achievements and failures (the biggest of which is not having a girlfriend yet) throughout the year.