Books

Machine Learning Basics

Introduction to Machine Learning

Supervised Learning

Unsupervised Learning

Feature Engineering

Model Evaluation

Conclusions

Unsupervised Learning

Introduction

Unsupervised learning is a type of machine learning where the algorithm works with unlabeled data to discover hidden patterns, structures, and relationships. Unlike supervised learning, there are no predefined correct answers or output labels.

Types of Unsupervised Learning

Clustering: Grouping similar data points together
Dimensionality Reduction: Reducing the number of features while preserving important information
Association Rule Mining: Discovering relationships between variables
Anomaly Detection: Identifying unusual data points

Clustering

Clustering algorithms partition data into groups (clusters) where items in the same group are similar to each other and different from items in other groups.

Common Clustering Algorithms:

K-Means Clustering
Hierarchical Clustering
DBSCAN (Density-Based Spatial Clustering)
Mean Shift Clustering
Gaussian Mixture Models

Example: Customer Segmentation

A retail company might use clustering to segment customers based on their purchasing behavior:

Features might include:

Purchase frequency
Average transaction value
Product categories purchased
Time since last purchase

Go Web Server

go web-server backend

2026-01-19T00:00:00

Go Web Server Example

This snippet shows a simple REST API server in Go with middleware.

      GO
    

    

    package main
    
    import (
        "context"
        "encoding/json"
        "fmt"
        "log"
        "net/http"
        "strconv"
        "time"
    
        "github.com/gorilla/mux"
    )
    
    type User struct {
        ID    int    `json:"id"`
        Name  string `json:"name"`
        Email string `json:"email"`
    }
    
    type Server struct {
        router *mux.Router
        users  []User
    }
    
    func NewServer() *Server {
        s := &Server{
            router: mux.NewRouter(),
            users: []User{
                {ID: 1, Name: "John Doe", Email: "john@example.com"},
                {ID: 2, Name: "Jane Smith", Email: "jane@example.com"},
            },
        }
        s.setupRoutes()
        return s
    }
    
    func (s *Server) setupRoutes() {
        // Middleware
        s.router.Use(s.loggingMiddleware)
        s.router.Use(s.corsMiddleware)
        
        // Routes
        s.router.HandleFunc("/api/users", s.getUsers).Methods("GET")
        s.router.HandleFunc("/api/users/{id}", s.getUser).Methods("GET")
        s.router.HandleFunc("/api/users", s.createUser).Methods("POST")
        s.router.HandleFunc("/api/users/{id}", s.updateUser).Methods("PUT")
        s.router.HandleFunc("/api/users/{id}", s.deleteUser).Methods("DELETE")
    }
    
    func (s *Server) loggingMiddleware(next http.Handler) http.Handler {
        return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
            start := time.Now()
            next.ServeHTTP(w, r)
            log.Printf(
                "%s %s %s %v",
                r.Method,
                r.RequestURI,
                r.RemoteAddr,
                time.Since(start),
            )
        })
    }
    
    func (s *Server) corsMiddleware(next http.Handler) http.Handler {
        return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
            w.Header().Set("Access-Control-Allow-Origin", "*")
            w.Header().Set("Access-Control-Allow-Methods", "GET, POST, PUT, DELETE, OPTIONS")
            w.Header().Set("Access-Control-Allow-Headers", "Content-Type")
            
            if r.Method == "OPTIONS" {
                w.WriteHeader(http.StatusOK)
                return
            }
            
            next.ServeHTTP(w, r)
        })
    }
    
    func (s *Server) getUsers(w http.ResponseWriter, r *http.Request) {
        w.Header().Set("Content-Type", "application/json")
        json.NewEncoder(w).Encode(s.users)
    }
    
    func (s *Server) getUser(w http.ResponseWriter, r *http.Request) {
        vars := mux.Vars(r)
        id, _ := strconv.Atoi(vars["id"])
        
        for _, user := range s.users {
            if user.ID == id {
                w.Header().Set("Content-Type", "application/json")
                json.NewEncoder(w).Encode(user)
                return
            }
        }
        
        http.NotFound(w, r)
    }
    
    func (s *Server) createUser(w http.ResponseWriter, r *http.Request) {
        var user User
        if err := json.NewDecoder(r.Body).Decode(&user); err != nil {
            http.Error(w, err.Error(), http.StatusBadRequest)
            return
        }
        
        user.ID = len(s.users) + 1
        s.users = append(s.users, user)
        
        w.Header().Set("Content-Type", "application/json")
        w.WriteHeader(http.StatusCreated)
        json.NewEncoder(w).Encode(user)
    }
    
    func (s *Server) updateUser(w http.ResponseWriter, r *http.Request) {
        vars := mux.Vars(r)
        id, _ := strconv.Atoi(vars["id"])
        
        var updatedUser User
        if err := json.NewDecoder(r.Body).Decode(&updatedUser); err != nil {
            http.Error(w, err.Error(), http.StatusBadRequest)
            return
        }
        
        for i, user := range s.users {
            if user.ID == id {
                updatedUser.ID = id
                s.users[i] = updatedUser
                w.Header().Set("Content-Type", "application/json")
                json.NewEncoder(w).Encode(updatedUser)
                return
            }
        }
        
        http.NotFound(w, r)
    }
    
    func (s *Server) deleteUser(w http.ResponseWriter, r *http.Request) {
        vars := mux.Vars(r)
        id, _ := strconv.Atoi(vars["id"])
        
        for i, user := range s.users {
            if user.ID == id {
                s.users = append(s.users[:i], s.users[i+1:]...)
                w.WriteHeader(http.StatusNoContent)
                return
            }
        }
        
        http.NotFound(w, r)
    }
    
    func main() {
        server := NewServer()
        
        fmt.Println("Server starting on port 8080...")
        log.Fatal(http.ListenAndServe(":8080", server.router))
    }
    
  

For real-time customer segmentation, a web server can process streaming data and update clusters dynamically. Go's concurrency features make it ideal for handling multiple customer data streams simultaneously:

      GO
    

    

    package main
    
    import (
        "fmt"
        "sync"
    )
    
    type Customer struct {
        ID       string
        Features []float64
    }
    
    func updateClusters(customers <-chan Customer) {
        for customer := range customers {
            // Update clustering model with new customer data
            fmt.Printf("Processing customer: %s\n", customer.ID)
        }
    }
    
    func main() {
        customerStream := make(chan Customer, 100)
        
        var wg sync.WaitGroup
        wg.Add(1)
        go func() {
            defer wg.Done()
            updateClusters(customerStream)
        }()
        
        // Simulate incoming customer data
        for i := 0; i < 10; i++ {
            customerStream <- Customer{
                ID: fmt.Sprintf("cust-%d", i),
                Features: []float64{float64(i), float64(i * 2)},
            }
        }
        
        close(customerStream)
        wg.Wait()
    }
    
  

Dimensionality Reduction

Dimensionality reduction techniques reduce the number of features while preserving as much information as possible. Common Techniques:

Principal Component Analysis (PCA)
t-SNE (t-Distributed Stochastic Neighbor Embedding)
Autoencoders (Neural Networks)
Factor Analysis

Rust Concurrent Programming

rust concurrent systems-programming

2026-01-19T00:00:00

Rust Concurrent Programming Example

This snippet demonstrates concurrent programming in Rust using threads and channels.

RUST


1
2    use std::sync::{Arc, Mutex};
3    use std::thread;
4    use std::time::Duration;
5    use std::sync::mpsc;
6    
7    fn main() {
8        println!("=== Rust Concurrent Programming Example ===\n");
9        
10        // Example 1: Basic thread spawning
11        basic_thread_example();
12        
13        // Example 2: Shared state with Arc<Mutex<>>
14        shared_state_example();
15        
16        // Example 3: Channel communication
17        channel_example();
18    }
19    
20    fn basic_thread_example() {
21        println!("1. Basic Thread Example:");
22        
23        let handles: Vec<_> = (0..5)
24            .map(|i| {
25                thread::spawn(move || {
26                    println!("Thread {} started", i);
27                    thread::sleep(Duration::from_millis(100 * i));
28                    println!("Thread {} finished", i);
29                    i * 2
30                })
31            })
32            .collect();
33        
34        for handle in handles {
35            let result = handle.join().unwrap();
36            println!("Thread result: {}", result);
37        }
38        println!();
39    }
40    
41    fn shared_state_example() {
42        println!("2. Shared State Example:");
43        
44        let counter = Arc::new(Mutex::new(0));
45        let mut handles = vec![];
46        
47        for _ in 0..10 {
48            let counter_clone = Arc::clone(&counter);
49            let handle = thread::spawn(move || {
50                let mut num = counter_clone.lock().unwrap();
51                *num += 1;
52            });
53            handles.push(handle);
54        }
55        
56        for handle in handles {
57            handle.join().unwrap();
58        }
59        
60        println!("Result: {}", *counter.lock().unwrap());
61        println!();
62    }
63    
64    fn channel_example() {
65        println!("3. Channel Communication Example:");
66        
67        let (tx, rx) = mpsc::channel();
68        
69        thread::spawn(move || {
70            let vals = vec![
71                String::from("hi"),
72                String::from("from"),
73                String::from("the"),
74                String::from("thread"),
75            ];
76            
77            for val in vals {
78                tx.send(val).unwrap();
79                thread::sleep(Duration::from_millis(100));
80            }
81        });
82        
83        for received in rx {
84            println!("Got: {}", received);
85        }
86        println!();
87    }

Rust's ownership model and fearless concurrency make it excellent for high-performance dimensionality reduction on large datasets. Here's how you might implement parallel PCA:

RUST


1
2    use rayon::prelude::*;
3    use ndarray::prelude::*;
4    
5    fn parallel_pca(data: &Array2<f64>, n_components: usize) -> Array2<f64> {
6        let (n_samples, n_features) = data.dim();
7        
8        // Center the data
9        let mean = data.mean_axis(Axis(0)).unwrap();
10        let centered = data - &mean;
11        
12        // Compute covariance matrix in parallel
13        let covariance = centered.t().dot(&centered) / (n_samples as f64 - 1.0);
14        
15        // Parallel eigenvalue decomposition
16        let (eigenvectors, _) = parallel_eigendecomposition(&covariance);
17        
18        // Return top components
19        eigenvectors.slice_axis(Axis(1), Slice::from(0..n_components)).to_owned()
20    }

Association Rule Mining

Association rule mining discovers interesting relationships between variables in large datasets.

Famous Example: Market Basket Analysis

The classic example is discovering that customers who buy diapers also tend to buy beer. Algorithm: Apriori

Find frequent itemsets
Generate association rules
Evaluate rules using support, confidence, and lift

TypeScript React Component

typescript react frontend

2026-01-19T00:00:00

TypeScript React Component Example

This snippet shows a TypeScript React component with proper typing.

      TYPESCRIPT
    

    

    import React, { useState, useEffect } from 'react';
    
    interface User {
      id: number;
      name: string;
      email: string;
      role: 'admin' | 'user' | 'moderator';
    }
    
    interface UserListProps {
      initialUsers: User[];
      onUserSelect?: (user: User) => void;
    }
    
    const UserList: React.FC<UserListProps> = ({ 
      initialUsers, 
      onUserSelect 
    }) => {
      const [users, setUsers] = useState<User[]>(initialUsers);
      const [filter, setFilter] = useState<string>('');
      const [loading, setLoading] = useState<boolean>(false);
      
      useEffect(() => {
        // Fetch users from API
        const fetchUsers = async () => {
          setLoading(true);
          try {
            const response = await fetch('/api/users');
            const data = await response.json();
            setUsers(data);
          } catch (error) {
            console.error('Failed to fetch users:', error);
          } finally {
            setLoading(false);
          }
        };
        
        fetchUsers();
      }, []);
      
      const filteredUsers = users.filter(user =>
        user.name.toLowerCase().includes(filter.toLowerCase()) ||
        user.email.toLowerCase().includes(filter.toLowerCase())
      );
      
      const handleUserClick = (user: User) => {
        onUserSelect?.(user);
      };
      
      if (loading) {
        return <div>Loading users...</div>;
      }
      
      return (
        <div className="user-list">
          <input
            type="text"
            placeholder="Filter users..."
            value={filter}
            onChange={(e) => setFilter(e.target.value)}
            className="filter-input"
          />
          <ul className="user-items">
            {filteredUsers.map(user => (
              <li
                key={user.id}
                onClick={() => handleUserClick(user)}
                className={`user-item ${user.role}`}
              >
                <span className="user-name">{user.name}</span>
                <span className="user-email">{user.email}</span>
                <span className="user-role">{user.role}</span>
              </li>
            ))}
          </ul>
        </div>
      );
    };
    
    export default UserList;
    
  

For interactive visualization of association rules, React components can provide dynamic filtering and highlighting:

      TYPESCRIPT
    

    

    import React, { useState, useMemo } from 'react';
    
    interface AssociationRule {
        antecedent: string[];
        consequent: string[];
        support: number;
        confidence: number;
        lift: number;
    }
    
    const AssociationRulesVisualization: React.FC<{ rules: AssociationRule[] }> = ({ rules }) => {
        const [minSupport, setMinSupport] = useState(0.1);
        const [minConfidence, setMinConfidence] = useState(0.5);
        
        const filteredRules = useMemo(() => {
            return rules.filter(rule => 
                rule.support >= minSupport && rule.confidence >= minConfidence
            );
        }, [rules, minSupport, minConfidence]);
        
        return (
            <div>
                <div>
                    <label>Min Support: {minSupport}</label>
                    <input 
                        type="range" 
                        min="0" 
                        max="1" 
                        step="0.01"
                        value={minSupport}
                        onChange={(e) => setMinSupport(parseFloat(e.target.value))}
                    />
                </div>
                <div>
                    <label>Min Confidence: {minConfidence}</label>
                    <input 
                        type="range" 
                        min="0" 
                        max="1" 
                        step="0.01"
                        value={minConfidence}
                        onChange={(e) => setMinConfidence(parseFloat(e.target.value))}
                    />
                </div>
                <ul>
                    {filteredRules.map((rule, index) => (
                        <li key={index}>
                            {rule.antecedent.join(', ')} → {rule.consequent.join(', ')}
                            <br />
                            <small>Support: {rule.support.toFixed(3)}, Confidence: {rule.confidence.toFixed(3)}</small>
                        </li>
                    ))}
                </ul>
            </div>
        );
    };
    
  

Anomaly Detection

Anomaly detection identifies data points that deviate significantly from the majority of the data. Applications:

Fraud detection
Network intrusion detection
Manufacturing defect detection
Healthcare monitoring

Books

Tags

Machine Learning Basics

Machine Learning Basics

Unsupervised Learning

Introduction

Types of Unsupervised Learning

Clustering

Example: Customer Segmentation

Go Web Server

Go Web Server Example

Dimensionality Reduction

Rust Concurrent Programming

Rust Concurrent Programming Example

Association Rule Mining

Famous Example: Market Basket Analysis

TypeScript React Component

TypeScript React Component Example

Anomaly Detection