Consider a rigid object with state \( \mathbf{x} \) (pose, shape, local geometry) and a robotic hand configuration \( g \) (palm pose and joint angles). A grasp synthesis algorithm selects a candidate \( g \) and produces a scalar \( Q(g, \mathbf{x}) \) describing grasp quality. A planner then searches over candidate grasps and chooses those with high quality.

Two major paradigms for computing \( Q(g,\mathbf{x}) \) are:

• Analytical grasping: uses explicit models of contact mechanics, friction cones, and grasp wrench space to compute a quality such as the Ferrari&Canny metric or a robust force-closure score.
• Data-driven grasping: treats grasping as a statistical learning problem, estimating \( P(Y=1 \mid \mathbf{x}, g) \), where \( Y \) is the success indicator, from data \((\mathbf{x}_i, g_i, y_i)\).

We can summarize both views as the construction of a function \( f(\mathbf{x}, g) \):

\[ f(\mathbf{x}, g) = \begin{cases} Q_{\text{ana}}(\mathbf{x}, g) & \text{(analytical, deterministic model)} \\ Q_{\text{data}}(\mathbf{x}, g) \approx P(Y=1 \mid \mathbf{x}, g) & \text{(data-driven)} \end{cases} \]

The central questions in this lesson are: how are these functions constructed, what assumptions they rely on, how they behave under modeling error and uncertainty, and how they can be combined.

flowchart TD
  X["Object representation x (mesh, point cloud)"] --> GA["Candidate grasp g (pose, joints)"]

  subgraph ANALYTICAL["Analytical pipeline"]
    GA --> C1["Contact model & friction parameters"]
    C1 --> GWS["Compute wrench set W(g)"]
    GWS --> Q1["Quality Q_ana(g,x) (e.g. epsilon metric)"]
  end

  subgraph DATA["Data-driven pipeline"]
    GA --> F1["Feature phi(x,g) (geometry, depths, etc.)"]
    F1 --> M1["Trained model f_theta"]
    M1 --> Q2["Quality Q_data(g,x) ~ P(success)"]
  end

  Q1 --> SEL["Grasp selection"]
  Q2 --> SEL
        

We recall the notion of grasp wrench space from Chapter 7. Let there be \( m \) contacts indexed by \( i = 1,\dots,m \). At each contact, the hand can apply a contact force \( \mathbf{f}_i \in \mathbb{R}^3 \), and this induces a wrench \( \mathbf{w}_i \in \mathbb{R}^6 \) on the object:

\[ \mathbf{w}_i = \begin{bmatrix} \mathbf{f}_i \\ \mathbf{p}_i \times \mathbf{f}_i \end{bmatrix}, \quad \mathbf{p}_i \in \mathbb{R}^3 \text{ is the contact position in object frame.} \]

With Coulomb friction coefficient \( \mu_i \), the admissible forces at contact \( i \) satisfy \( \|\mathbf{f}_{i,t}\|_2 \le \mu_i f_{i,n} \) and \( f_{i,n} \ge 0 \), where \( f_{i,n} \) is the normal component and \( \mathbf{f}_{i,t} \) the tangential part. The associated friction cone is a second-order (quadratic) cone.

For efficient computation, we approximate each friction cone by a polyhedral cone with \( k_i \) edges. Let \( \mathbf{f}_{i,1},\dots,\mathbf{f}_{i,k_i} \) be unit edge directions with \( f_{i,l,n} > 0 \). Each edge direction induces a primitive wrench \( \mathbf{w}_{i,l} \in \mathbb{R}^6 \). Stacking all primitive wrenches as columns yields the grasp map \( \mathbf{G} \in \mathbb{R}^{6 \times p} \), where \( p = \sum_i k_i \):

\[ \mathbf{G} = \begin{bmatrix} \mathbf{w}_{1,1} & \cdots & \mathbf{w}_{1,k_1} & \cdots & \mathbf{w}_{m,1} & \cdots & \mathbf{w}_{m,k_m} \end{bmatrix}. \]

Let \( \boldsymbol{\lambda} \in \mathbb{R}^p \) denote the nonnegative scalar magnitudes of the primitive wrenches. The set of wrenches the hand can apply is then

\[ \mathcal{W}(g) = \left\{ \mathbf{w} \in \mathbb{R}^6 \;\middle|\; \mathbf{w} = \mathbf{G}\boldsymbol{\lambda},\; \boldsymbol{\lambda} \ge \mathbf{0} \right\}. \]

The convex hull of column vectors of \( \mathbf{G} \) characterizes the grasp's ability to resist external wrenches. A grasp has force closure if \( \mathbf{0} \) lies in the interior of the convex hull of \( \mathcal{W}(g) \). A widely used quality metric is the Ferrari&Canny \( \epsilon \)-metric:

\[ Q_{\epsilon}(g) = \sup \left\{ r \ge 0 \;\middle|\; \mathbb{B}_2(\mathbf{0}, r) \subseteq \operatorname{conv}\bigl(\mathcal{W}(g)\bigr) \right\}, \]

where \( \mathbb{B}_2(\mathbf{0}, r) \) is the Euclidean ball of radius \( r \) in wrench space. Intuitively, \( Q_{\epsilon}(g) \) is the radius of the largest origin-centered ball fully contained in the convex hull of primitive wrenches: the larger the radius, the more robustly the grasp can counteract disturbances.

Numerically, one can approximate this quantity by solving a family of convex optimization problems over directions \( \mathbf{v} \in \mathbb{R}^6 \) with \( \|\mathbf{v}\|_2 = 1 \):

\[ Q_{\epsilon}(g) = \min_{\|\mathbf{v}\|_2 = 1} \max_{j=1,\dots,p} \mathbf{v}^{\top} \mathbf{w}_j. \]

This analytical definition depends critically on accurate contact locations, normals, and friction, and on the validity of quasi-static rigid-body assumptions.

Real systems rarely match the exact analytical model. Contact positions \( \mathbf{p}_i \) and normals, friction \( \mu_i \), and even the object model are uncertain. Let \( \boldsymbol{\delta} \) collect all such perturbations, and define the perturbed grasp map \( \mathbf{G}(\boldsymbol{\delta}) \). A robust analytical metric explicitly accounts for this:

\[ Q_{\text{rob}}(g) = \inf_{\boldsymbol{\delta} \in \mathcal{U}} Q_{\epsilon}\bigl(g; \mathbf{G}(\boldsymbol{\delta})\bigr), \]

where \( \mathcal{U} \) is a bounded uncertainty set (e.g., intervals for contact positions). The robust quality problem is typically harder than computing \( Q_{\epsilon} \) once; it requires either:

• Worst-case analysis: analytical bounds on how much \( Q_{\epsilon} \) can deteriorate as \( \|\boldsymbol{\delta}\| \) grows.
• Scenario optimization: sampling \( \boldsymbol{\delta}_1,\dots,\boldsymbol{\delta}_N \) from the uncertainty distribution and defining \( Q_{\text{rob}}(g) = \min_s Q_{\epsilon}(g; \boldsymbol{\delta}_s) \).

This illustrates a key limitation of purely analytical methods: if the model is strongly misspecified, the resulting \( Q_{\text{rob}} \) may either be too pessimistic (underestimating good grasps) or overly optimistic (overestimating unreliable grasps when unmodeled effects dominate).

Data-driven grasping replaces or augments analytical models with models learned from examples. We collect a dataset

\[ \mathcal{D} = \left\{ \bigl(\mathbf{x}_i, g_i, y_i\bigr) \right\}_{i=1}^N, \quad y_i \in \{0,1\} \text{ indicates grasp success.} \]

Here \( \mathbf{x}_i \) encodes the sensed object and environment (e.g., depth image, point cloud, pose), and \( g_i \) a candidate grasp (pose and hand shape). A data-driven grasp model is a parameterized function \( f_{\boldsymbol{\theta}}(\mathbf{x}, g) \) with output in \( (0,1) \), interpreted as \( P(Y=1 \mid \mathbf{x}, g) \).

A simple but important example is logistic regression on a hand-crafted feature vector \( \boldsymbol{\phi}(\mathbf{x}, g) \in \mathbb{R}^d \):

\[ f_{\boldsymbol{\theta}}(\mathbf{x}, g) = \sigma\bigl(\boldsymbol{\theta}^{\top} \boldsymbol{\phi}(\mathbf{x}, g)\bigr), \quad \sigma(z) = \frac{1}{1 + e^{-z}}. \]

The parameter vector \( \boldsymbol{\theta} \) is estimated by minimizing empirical cross-entropy (negative log-likelihood):

\[ \hat{\boldsymbol{\theta}} = \arg\min_{\boldsymbol{\theta}} \frac{1}{N} \sum_{i=1}^N \Bigl[ -y_i \log f_{\boldsymbol{\theta}}(\mathbf{x}_i, g_i) -(1-y_i)\log\bigl(1-f_{\boldsymbol{\theta}}(\mathbf{x}_i, g_i)\bigr) \Bigr]. \]

The gradient of this loss is

\[ \nabla_{\boldsymbol{\theta}} \mathcal{L} = -\frac{1}{N} \sum_{i=1}^N \bigl(y_i - f_{\boldsymbol{\theta}}(\mathbf{x}_i, g_i)\bigr) \boldsymbol{\phi}(\mathbf{x}_i, g_i), \]

yielding a straightforward gradient-descent update rule. More complex models (e.g., multi-layer neural networks) replace the linear mapping \( \boldsymbol{\theta}^{\top} \boldsymbol{\phi} \) by a deeper parameterization, but the learning principle is the same.

A key advantage is that unmodeled physical phenomena (e.g., slight compliance, sensor artifacts) can, in principle, be captured implicitly if they correlate with input features. The main limitations are:

• Need for many labeled grasps (sample complexity).
• Generalization to new objects outside the training distribution.
• Lack of explicit physical guarantees (e.g., provable force closure).

Analytical and data-driven approaches need not be antagonistic. A powerful strategy is to embed analytical information into the learning pipeline. Let \( Q_{\text{ana}}(g,\mathbf{x}) \) be an analytical metric (e.g. \( Q_{\epsilon} \) or a robust variant). We can define a hybrid feature vector

\[ \boldsymbol{\phi}_{\text{hyb}}(\mathbf{x}, g) = \begin{bmatrix} \boldsymbol{\phi}_{\text{geom}}(\mathbf{x}, g) \\ Q_{\text{ana}}(g,\mathbf{x}) \end{bmatrix}, \]

and train a data-driven model on \( \boldsymbol{\phi}_{\text{hyb}} \). This yields a predictor that can:

• Preserve some physical interpretability via \( Q_{\text{ana}} \).
• Statistically calibrate the analytical metric to real-world success probabilities (e.g., learning a nonlinear mapping from \( Q_{\text{ana}} \) to success likelihood).
• Compensate for systematic modeling biases (e.g., underestimated friction).

Hybrid models are an example of a broader pattern: using analytical models to define hypothesis classes or priors, and data to refine or correct them.

Let \( \ell(y, s) \) be a loss (e.g., 0-1 or cross-entropy), and let \( s(\mathbf{x}, g) \) be either an analytical score \( Q_{\text{ana}} \) or a learned score \( Q_{\text{data}} \). The risk of a scoring rule is

\[ R(s) = \mathbb{E}\bigl[ \ell\bigl(Y, s(\mathbf{X}, G)\bigr) \bigr], \]

where the expectation is over the distribution of objects, grasps, and outcomes.

For an analytical score \( Q_{\text{ana}} \), the risk is determined by the modeling error alone; there is no statistical estimation error. This is a low-variance, potentially high-bias situation: repeated experiments under the same analytical model yield the same predictions, but the model may be systematically wrong if physics are incomplete.

For a data-driven score \( Q_{\text{data}} = f_{\hat{\boldsymbol{\theta}}} \), we approximate the risk by the empirical risk

\[ \hat{R}_N(f_{\hat{\boldsymbol{\theta}}}) = \frac{1}{N} \sum_{i=1}^N \ell\bigl(y_i, f_{\hat{\boldsymbol{\theta}}}(\mathbf{x}_i, g_i)\bigr), \]

and generalization theory (e.g., via VC-dimension or Rademacher complexity) provides bounds of the form

\[ R\bigl(f_{\hat{\boldsymbol{\theta}}}\bigr) \le \hat{R}_N\bigl(f_{\hat{\boldsymbol{\theta}}}\bigr) + \mathcal{O}\!\left(\sqrt{\frac{\mathcal{C}}{N}}\right), \]

where \( \mathcal{C} \) is a capacity measure of the model class. Large flexible models (e.g., deep networks for grasp images) have large \( \mathcal{C} \), requiring many examples to achieve small risk.

In practice, the choice between analytical and data-driven (or hybrid) methods depends on this trade-off:

• If accurate models with small uncertainty sets are available and the operational domain is narrow, analytical methods can be highly effective.
• If data is plentiful and the environment is complex or poorly modeled, data-driven or hybrid approaches are preferable.

We implement a simplified grasp evaluation in Python. The code:

• Builds a toy grasp matrix \( \mathbf{G} \).
• Computes an approximate Ferrari&Canny style quality by sampling directions.
• Uses the analytical quality as a feature in a logistic regression model that predicts binary labels.

import numpy as np
from numpy.linalg import norm

# ----- Part 1: toy grasp map G (6 x p) -----
def random_wrench():
    # Random contact wrench with limited magnitude
    w = np.random.randn(6)
    return w / norm(w)

def build_grasp_map(num_contacts=4, rays_per_contact=4, seed=0):
    rng = np.random.RandomState(seed)
    W = []
    for i in range(num_contacts):
        for r in range(rays_per_contact):
            w = rng.randn(6)
            w = w / np.linalg.norm(w)
            W.append(w)
    G = np.stack(W, axis=1)  # 6 x p
    return G

# ----- Part 2: approximate epsilon-quality by sampling directions -----
def epsilon_quality(G, num_dirs=200):
    # G: 6 x p matrix of primitive wrenches
    p = G.shape[1]
    eps = np.inf
    for _ in range(num_dirs):
        v = np.random.randn(6)
        v = v / norm(v)
        # support function h(v) = max_j v^T w_j
        support = np.max(v.dot(G))
        eps = min(eps, support)
    return float(max(eps, 0.0))

# ----- Part 3: build synthetic dataset for calibration -----
def synthetic_dataset(num_samples=200):
    X_feat = []
    y = []
    for i in range(num_samples):
        G = build_grasp_map(seed=i)
        q = epsilon_quality(G)
        # "Ground-truth" success probability is a saturating function of q
        p_success = 1.0 / (1.0 + np.exp(-5.0 * (q - 0.2)))
        label = np.random.rand() < p_success
        X_feat.append([q])
        y.append(1 if label else 0)
    return np.array(X_feat), np.array(y)

# ----- Part 4: logistic regression training (1D feature) -----
def train_logistic_regression(X, y, lr=0.5, epochs=200):
    # X: (N,1), y: (N,)
    w = 0.0
    b = 0.0
    for _ in range(epochs):
        z = w * X[:, 0] + b
        p = 1.0 / (1.0 + np.exp(-z))
        grad_w = -np.mean((y - p) * X[:, 0])
        grad_b = -np.mean(y - p)
        w -= lr * grad_w
        b -= lr * grad_b
    return w, b

def predict_success_prob(q, w, b):
    z = w * q + b
    return 1.0 / (1.0 + np.exp(-z))

if __name__ == "__main__":
    X, y = synthetic_dataset(num_samples=300)
    w, b = train_logistic_regression(X, y)
    test_G = build_grasp_map(seed=999)
    q_test = epsilon_quality(test_G)
    p_hat = predict_success_prob(q_test, w, b)
    print("Analytical quality q =", q_test)
    print("Predicted success probability =", p_hat)
      

This example illustrates a typical hybrid workflow: an analytical engine computes a physically interpretable scalar \( q = Q_{\text{ana}}(g) \), and a learned calibration maps \( q \) to a success probability.

The following C++ snippet sketches how one might represent a grasp map and compute an approximate quality by sampling directions. For linear algebra, a library such as Eigen is typical in robotics software stacks.

#include <iostream>
#include <vector>
#include <random>
#include <Eigen/Dense>

using Wrench = Eigen::Matrix<double, 6, 1>;
using GraspMap = Eigen::Matrix<double, 6, Eigen::Dynamic>;

Wrench randomWrench(std::mt19937 &gen) {
    std::normal_distribution<double> dist(0.0, 1.0);
    Wrench w;
    for (int i = 0; i < 6; ++i) {
        w(i) = dist(gen);
    }
    double nrm = w.norm();
    if (nrm > 1e-9) {
        w /= nrm;
    }
    return w;
}

GraspMap buildGraspMap(std::size_t numContacts,
                       std::size_t raysPerContact,
                       std::mt19937 &gen) {
    std::size_t p = numContacts * raysPerContact;
    GraspMap G(6, static_cast<int>(p));
    std::size_t col = 0;
    for (std::size_t i = 0; i < numContacts; ++i) {
        for (std::size_t r = 0; r < raysPerContact; ++r) {
            G.col(static_cast<int>(col)) = randomWrench(gen);
            ++col;
        }
    }
    return G;
}

double epsilonQuality(const GraspMap &G, std::size_t numDirs,
                      std::mt19937 &gen) {
    std::normal_distribution<double> dist(0.0, 1.0);
    double eps = std::numeric_limits<double>::infinity();
    for (std::size_t k = 0; k < numDirs; ++k) {
        Wrench v;
        for (int i = 0; i < 6; ++i) {
            v(i) = dist(gen);
        }
        double nrm = v.norm();
        if (nrm > 1e-9) v /= nrm;
        Eigen::RowVectorXd vT = v.transpose();
        Eigen::RowVectorXd proj = vT * G;  // 1 x p
        double support = proj.maxCoeff();
        if (support < eps) eps = support;
    }
    return std::max(0.0, eps);
}

int main() {
    std::mt19937 gen(42);
    GraspMap G = buildGraspMap(4, 4, gen);
    double q = epsilonQuality(G, 200, gen);
    std::cout << "Approximate epsilon quality: " << q << std::endl;
    return 0;
}
      

In a full system, the primitive wrenches would be derived from actual contact geometry and friction cones, and this routine would be used inside a search or optimization loop over candidate grasps.

Java is frequently used in larger robotics software systems or simulation environments. The following example shows a minimal logistic calibration of an analytical score, using plain arrays.

public class GraspScoring {

    // Sigmoid function
    private static double sigmoid(double z) {
        return 1.0 / (1.0 + Math.exp(-z));
    }

    // Train 1D logistic regression with gradient descent
    public static double[] trainLogistic(double[] q, int[] y,
                                         double lr, int epochs) {
        double w = 0.0;
        double b = 0.0;
        int n = q.length;
        for (int e = 0; e < epochs; ++e) {
            double gradW = 0.0;
            double gradB = 0.0;
            for (int i = 0; i < n; ++i) {
                double z = w * q[i] + b;
                double p = sigmoid(z);
                gradW += -(y[i] - p) * q[i];
                gradB += -(y[i] - p);
            }
            gradW /= n;
            gradB /= n;
            w -= lr * gradW;
            b -= lr * gradB;
        }
        return new double[]{w, b};
    }

    public static double predict(double q, double w, double b) {
        return sigmoid(w * q + b);
    }

    public static void main(String[] args) {
        double[] qVals = {0.1, 0.2, 0.25, 0.4, 0.5};
        int[] labels = {0, 0, 1, 1, 1};
        double[] params = trainLogistic(qVals, labels, 0.5, 200);
        double w = params[0];
        double b = params[1];
        double qTest = 0.3;
        double pHat = predict(qTest, w, b);
        System.out.println("Predicted success probability: " + pHat);
    }
}
      

Here the vector qVals corresponds to analytical qualities \( Q_{\text{ana}} \), and the trained predictor provides a probabilistic interpretation of these scores.

MATLAB is widely used in robotics prototyping, and Simulink can encapsulate grasp quality computations as blocks within a manipulation pipeline (e.g., connecting perception, planning, and control subsystems).

The following script constructs a simple grasp map and evaluates the sampled epsilon-quality:

function q = epsilon_quality_matlab(G, numDirs)
% G: 6 x p matrix of primitive wrenches
if nargin < 2
    numDirs = 200;
end
epsVal = inf;
for k = 1:numDirs
    v = randn(6,1);
    v = v / norm(v);
    proj = v' * G;           % 1 x p
    support = max(proj);
    epsVal = min(epsVal, support);
end
q = max(epsVal, 0.0);
end

% Example usage:
p = 16;
G = randn(6, p);
for j = 1:p
    G(:,j) = G(:,j) / norm(G(:,j));
end
q_example = epsilon_quality_matlab(G, 300);
fprintf('Approximate epsilon quality: %.4f\n', q_example);
      

In Simulink, one can wrap epsilon_quality_matlab inside a MATLAB Function block that accepts an object-specific grasp map and outputs a scalar quality used by a higher-level planner.

Mathematica is convenient for symbolic derivations of grasp maps and friction cone approximations. The following code computes primitive wrenches for planar contacts and builds a 3D wrench map (force in plane plus torque):

(* Planar contact at position p = (px, py) with friction coefficient mu *)
ClearAll[primitiveWrenches2D]
primitiveWrenches2D[{px_, py_}, mu_, k_Integer] := Module[
  {angles, dirs, wrenches},
  angles = Subdivide[-ArcTan[mu], ArcTan[mu], k - 1];
  dirs = { {Cos[#], Sin[#]} & /@ angles };
  wrenches = Table[
    With[{fx = dirs[[j, 1]], fy = dirs[[j, 2]]},
      {
        fx,
        fy,
        px fy - py fx (* torque about origin *)
      }
    ],
    {j, 1, k}
  ];
  wrenches
]

(* Example: two contacts and symbolic grasp map *)
px1 = 0; py1 = 1;
px2 = 0; py2 = -1;
mu = 0.5;
k = 4;

W1 = primitiveWrenches2D[{px1, py1}, mu, k];
W2 = primitiveWrenches2D[{px2, py2}, mu, k];
G = Transpose[Join[W1, W2]]; (* 3 x 2k grasp map *)

MatrixForm[G]
      

Extending this construction to 6D wrenches and exploring symbolic conditions for force-closure (e.g., rank conditions and convex hull properties) is a useful way to deepen understanding of analytical grasping.

Problem 1 (Planar Force-Closure Condition): Consider a planar object in \( SE(2) \) with two point contacts on opposite sides, at positions \( \mathbf{p}_1 = (0,1) \) and \( \mathbf{p}_2 = (0,-1) \). Assume friction coefficient \( \mu > 0 \) and that each friction cone is approximated by two edges symmetric around the inward normal. Show that, for sufficiently large \( \mu \), the grasp can achieve force closure in the plane (three-dimensional wrench space).

Solution:

The planar wrench vector is \( \mathbf{w} = (f_x, f_y, \tau_z)^{\top} \). For contact 1, located at \( (0,1) \) with inward normal \( (0,-1) \), the friction cone edges in force space may be parameterized as

\[ \mathbf{f}_{1,\pm} = f_n \begin{bmatrix} \pm \mu \\ -1 \end{bmatrix}, \quad f_n \ge 0. \]

The corresponding torques are \( \tau_{1,\pm} = p_{1,x} f_{1,\pm,y} - p_{1,y} f_{1,\pm,x} = -1 \cdot (\pm \mu f_n) \). Thus the primitive wrenches at contact 1 are

\[ \mathbf{w}_{1,\pm} = \begin{bmatrix} \pm \mu f_n \\ -f_n \\ \mp \mu f_n \end{bmatrix}. \]

A similar calculation for contact 2, at \( (0,-1) \) with inward normal \( (0,1) \), yields primitive wrenches

\[ \mathbf{w}_{2,\pm} = \begin{bmatrix} \pm \mu f_n \\ f_n \\ \pm \mu f_n \end{bmatrix}. \]

The convex cone generated by these four primitive wrenches spans all three dimensions if the set \( \{\mathbf{w}_{1,+},\mathbf{w}_{1,-},\mathbf{w}_{2,+},\mathbf{w}_{2,-}\} \) is not contained in any proper subspace. For \( \mu > 0 \), one can verify that these four vectors are not coplanar: their determinant (taking three of them as a basis) is nonzero for generic \( \mu \). Therefore the wrench set spans \( \mathbb{R}^3 \). Furthermore, the friction cones contain both positive and negative directions for torque and horizontal force, so \( \mathbf{0} \) lies in the interior of the convex hull for sufficiently large \( \mu \), establishing planar force closure.

Problem 2 (Analytical vs Probabilistic Scoring): Suppose an analytical metric \( Q_{\text{ana}} \) is monotonically related to the true success probability via \( P(Y=1 \mid q) = \sigma(a q + b) \) for some \( a > 0 \), \( b \). Show that logistic regression with feature \( q \) can recover this mapping (up to statistical error).

Solution:

Logistic regression with feature \( q \) assumes a model \( P_{\boldsymbol{\theta}}(Y=1 \mid q) = \sigma(\theta_1 q + \theta_0) \). If the true distribution obeys \( P(Y=1 \mid q) = \sigma(a q + b) \), then the model class contains the true distribution with parameters \( \theta_1 = a \), \( \theta_0 = b \). Under standard regularity conditions, maximum likelihood estimation is consistent, so as \( N \to \infty \), the empirical optimizer converges (in probability) to \( (a,b) \). Thus logistic regression can statistically recover the correct calibration of the analytical score.

Problem 3 (Capacity and Sample Complexity): Consider two data-driven grasp models trained on the same dataset: (i) a logistic regression on a scalar analytic feature \( q \), and (ii) a high-capacity model with VC-dimension \( d \). Assuming both models achieve zero empirical 0-1 loss on the training data, explain why the high-capacity model may have worse true risk than the logistic model when \( N \) is not much larger than \( d \).

Solution:

Generalization bounds based on VC-dimension have the form

\[ R(h) \le \hat{R}_N(h) + C \sqrt{\frac{d}{N}}, \]

for some constant \( C \). When both models fit the training data perfectly, \( \hat{R}_N(h) = 0 \), but the additive term is larger for the high-capacity model. If \( N \) is only a small multiple of \( d \), the bound becomes loose, and the model may overfit noise in the data. The logistic regression with very small effective capacity (roughly one or two parameters) has a much smaller complexity term and therefore better guaranteed generalization, despite identical empirical performance.

Problem 4 (Hybrid Feature Design): Let \( \boldsymbol{\phi}_{\text{geom}}(\mathbf{x}, g) \) be a purely geometric feature vector. Define \( \boldsymbol{\phi}_{\text{hyb}}(\mathbf{x}, g) \) as in Section 5 by appending \( Q_{\text{ana}}(g,\mathbf{x}) \). Argue qualitatively (no formal proof needed) why this cannot worsen the Bayes-optimal risk compared to using \( \boldsymbol{\phi}_{\text{geom}} \) alone if the learning algorithm can ignore useless features.

Solution:

The Bayes-optimal predictor in the feature space \( \boldsymbol{\phi} \) is \( f^{\star}(\boldsymbol{\phi}) = P(Y=1 \mid \boldsymbol{\phi}) \). Augmenting the feature vector yields a richer feature space \( \boldsymbol{\phi}_{\text{hyb}} \), but the learner is free to assign zero weight to \( Q_{\text{ana}} \) if it is not informative. Therefore the Bayes risk in the augmented feature space is no worse than in the original space. In finite-sample practice, the augmented feature may slightly increase estimation variance, but with appropriate regularization, the learner can still suppress unhelpful dimensions.

Problem 5 (Design Flow for Choosing Analytical vs Data-Driven): Sketch a decision flow for selecting between an analytical, data-driven, or hybrid grasping pipeline given: (i) availability of accurate object and contact models, (ii) availability of grasp datasets, and (iii) computational budget.

Solution (flow):

flowchart TD
  S["Start"] --> M["Accurate models of \ngeometry & friction?"]
  M -->|"yes"| DSET["Large grasp dataset available?"]
  M -->|"no"| DSET2["Moderate dataset available?"]

  DSET -->|"yes"| HYB["Use hybrid: \nanalytic features + \nlearning"]
  DSET -->|"no"| ANA["Use analytic quality \n(e.g. epsilon metric)"]

  DSET2 -->|"yes"| DD["Use data-driven \n(images, point clouds)"]
  DSET2 -->|"no"| LOW["Use simple analytic \nheuristics and \nconservative planning"]

  HYB --> COST["Check computational budget"]
  ANA --> COST
  DD --> COST
  LOW --> COST

  COST -->|"tight"| FAST["Simplify model / precompute scores"]
  COST -->|"ample"| FULL["Use full solver or larger network"]
        

The flow emphasizes that when accurate models and plenty of data coexist, hybrid approaches are often preferable; with poor models but ample data, one leans toward data-driven methods; and in data-scarce, model-scarce regimes, simple analytical heuristics with conservative safety margins are most realistic.

In this lesson we contrasted analytical and data-driven approaches to grasp synthesis. Analytical methods rely on explicit contact and friction models, constructing grasp maps and wrench spaces to compute metrics such as the Ferrari&Canny \( \epsilon \)-quality and its robust variants. These methods provide strong physical insight and, in some cases, provable guarantees, but are sensitive to modeling inaccuracies.

Data-driven grasping formulates success prediction as a supervised learning problem over object and grasp descriptors, using models such as logistic regression or higher-capacity networks. These approaches can capture complex, unmodeled phenomena at the cost of data requirements and reduced interpretability.

Hybrid methods incorporate analytical scores as features or constraints, combining physical structure with empirical calibration. Through mathematical risk analysis and multiple programming examples in Python, C++, Java, MATLAB, and Mathematica, we have built a foundation for more advanced topics in grasp synthesis, including antipodal and multi-finger planning in the next lesson.