In this quickstart, you'll learn how to build a complete machine learning lifecycle in Snowflake, from model development to deployment. You'll deploy HuggingFace models, train custom ML models, track experiments, deploy for inference, and enable real-time feature serving.

A production-ready ML system that:

1. Download the setup.sql file from the source repository
2. Open a new worksheet in Snowflake
3. Click the Open file button (or use File > Open from the menu)
4. Select the setup.sql file you downloaded
5. Run all statements in the script to create:
   • Database: BUILD25_DEV_TO_PRODUCTION
   • Schema: DATA
   • Stage: audio_files (with directory enabled)

The setup script will create all the necessary infrastructure for this quickstart.

Before extracting features, you need to import the sentiment analysis model into the Model Registry:

1. In your Snowflake account, click on AI & ML in the left navigation menu
2. Click on Models

3. In the top right corner, click Import Model

4. In the Import Model dialog:

   • For Model Handle, enter: tabularisai/multilingual-sentiment-analysis
   • For Task, select: Text Classification
   • The Model Name will auto-populate as MULTILINGUAL_SENTIMENT_ANALYSIS
   • For Database, select: BUILD25_DEV_TO_PRODUCTION
   • For Schema, select: DATA

5. Click Import

The model will be imported into your Model Registry and will be available for use in the notebook.

After import completes, you should see the model MULTILINGUAL_SENTIMENT_ANALYSIS listed in your Models under BUILD25_DEV_TO_PRODUCTION.DATA schema.

1. Download the Notebook from GitHub (NOTE: Do NOT right-click to download.)
2. In your Snowflake account:
   • On the left hand navigation menu, click on Projects → Notebooks
   • On the top right, click on Notebook down arrow and select Import .ipynb file from the dropdown menu
   • Select the file you downloaded in step 1 above
3. In the Create Notebook popup:
   • For Notebook location, select BUILD25_DEV_TO_PRODUCTION for your database and DATA as your schema
   • For Runtime, select Container Runtime
   • Click on Create button
4. On the top right open Notebook Settings
   • Click External Access
   • Enable PyPi
   • Click Save

The notebook will run on container runtime, which provides the necessary environment for running ML workloads with GPU support. The notebook will guide you through installing required packages including PyTorch, Transformers, Librosa, Whisper, and other ML libraries needed for audio processing and model training.

In the notebook, you'll create a table that catalogs all audio files in the stage. This table includes:

The notebook includes commands to verify the file count and display a sample of available files.

The notebook includes a comprehensive HuggingFaceAcousticExtractor class that extracts multiple types of features from call audio:

Acoustic Features (17 features):

Interaction Features (4 features):

Emotion Features (4 features):

Content Features (7 features):

For each audio file, the system:

1. Downloads the file from the Snowflake stage
2. Uses Whisper to transcribe the audio
3. Extracts acoustic features using librosa
4. Analyzes emotions using wav2vec2 models
5. Performs Named Entity Recognition on transcripts
6. Analyzes sentiment using the model from the Model Registry
7. Stores all 32+ features in a structured table

This process leverages multiple state-of-the-art models to create a comprehensive feature set for training.

After extraction completes, you can review the results in the call_acoustic_features table. The notebook includes queries to examine transcripts, emotions, stress levels, and other extracted features.

Since manually labeling call quality is time-consuming, you'll use Snowflake Cortex to automatically analyze calls and generate quality labels. The system uses Claude Sonnet 4.5 to:

1. Read the full transcript
2. Consider acoustic context (emotion, stress, interruptions)
3. Determine if the call was resolved
4. Rate customer satisfaction (1-5 scale)
5. Assess resolution confidence
6. Provide reasoning for the assessment

The generated outcomes table includes:

The notebook includes queries to check the quality distribution and verify the labeled dataset.

The notebook uses Snowflake ML's experiment tracking to systematically compare different modeling approaches. All experiments are logged under the call_quality_prediction_with_ner experiment name.

A "high quality call" is defined as one where the issue was resolved and customer satisfaction was 4 or higher.

The data is split into three sets:

The notebook trains four different models for comparison:

Experiment 1: Optimized XGBoost with All Features

Experiment 2: Acoustic Features Only

Experiment 3: NER + Emotion Features

Experiment 4: SMOTE Balanced Data

All experiments log model parameters, performance metrics (accuracy, precision, recall, F1, AUC), optimal prediction threshold, and trained model artifacts. You can compare experiments in Snowflake to determine which approach works best.

Using the Model Registry, you'll load the best-performing model version. The registry provides model versioning, lineage, metadata, and metrics.

Deploy your model as a service using Snowflake's built-in compute pool. This creates:

The notebook will use the available GPU compute pool for model deployment.

Test the deployed service using your holdout calls. The notebook demonstrates:

1. Loading the holdout call IDs
2. Retrieving their features
3. Calling the prediction service
4. Comparing predictions to actual outcomes

All predictions are saved to a monitoring table with metadata including timestamp, model name/version, prediction threshold, service name, and actual outcome.

Configure the model task type as binary classification so monitoring can calculate appropriate metrics like accuracy, precision, recall, and AUC.

Create a baseline using recent predictions (last 100 calls) to represent "normal" model performance. This baseline will be used to detect:

Set up automated monitoring that:

Feature stores solve the challenge of serving features consistently between training (batch) and inference (real-time). They provide:

Initialize a feature store in your database and register the call entity with its join key (call_id).

Create three feature views, each with online serving enabled:

Acoustic Features View:

Emotion & Sentiment Features View:

NER & Content Features View:

Each feature view is backed by a dynamic table that automatically refreshes and an online table for fast point lookups.

Verify that online serving works by getting a sample call ID, retrieving specific features using the online store, and confirming sub-30-second latency.

The notebook includes a built-in Streamlit cell that creates an interactive real-time dashboard. Simply run the Streamlit cell in the notebook to launch the application.

The dashboard will open directly within your notebook environment, allowing you to monitor calls without leaving your workspace.

The real-time dashboard provides supervisors with instant visibility into call quality:

Live Monitoring Display:

Priority-Based Coaching Suggestions:

Detailed Call Metrics:

Interactive Controls:

The dashboard uses the online feature store for low-latency retrieval (under 30 seconds) and provides supervisors with actionable insights for coaching agents in real-time.

Congratulations! You've successfully built a complete ML lifecycle in Snowflake that transforms call center audio into actionable insights. You imported a HuggingFace model into the Model Registry, extracted comprehensive features, trained multiple ML models with experiment tracking, deployed models as services, set up monitoring, and enabled real-time feature serving with a Streamlit dashboard - all within Snowflake's unified platform.

Documentation: