Torsie in ronde assen

Torsie

• Torsie treedt op bij een rechte staaf wanneer deze wordt belast door draaiende koppels of momenten, wat resulteert in rotatie rond de lengteas.
• Voorbeelden zijn aandrijfassen en assen.

Aannames voor torsie van ronde assen

• De doorsnede is cirkelvormig.
• De draai-as loopt recht.
• De as is homogeen en isotroop.
• Er is sprake van een statisch draaimoment.

Belangrijkste resultaten

• De schuifspanning varieert lineair vanaf de centrale as.
• De maximale schuifspanning treedt op aan het buitenoppervlak.
• Vlakke doorsneden blijven vlak en onvervormd.

Schuifspanningen in het elastische bereik

• De schuifspanning $(\tau)$ is gelijk aan het product van de schuifmodulus van elasticiteit (G) en de schuifrek $(\gamma)$: $\tau = G\gamma$.
• De schuifrek kan worden uitgedrukt als $\gamma = \dfrac{r\theta}{L}$, waarbij r de straal van de as is, $\theta$ de draaihoek in radialen en L de lengte van de as.
• De schuifspanning kan ook worden uitgedrukt als $\tau = \dfrac{Gr\theta}{L}$.
• De maximale schuifspanning wordt gegeven door $\tau_{max} = \dfrac{Gr_o\theta}{L}$, waarbij $r_o$ de buitenste straal van de as is.
• De schuifspanning varieert lineair met de radiale afstand vanaf de as van de as: $\tau = \dfrac{r}{r_o} \tau_{max}$.

Draaiformule

• De formule voor het berekenen van de schuifspanning als gevolg van torsie is: $T = \int_A r\tau dA = \int_A r(\dfrac{r}{r_o} \tau_{max}) dA = \dfrac{\tau_{max}}{r_o} \int_A r^2 dA$
• Dit kan vereenvoudigd worden tot $T = \dfrac{\tau_{max}}{r_o} J$, waarbij T het interne draaimoment is en J het polaire traagheidsmoment.
• De maximale schuifspanning kan worden berekend met $\tau_{max} = \dfrac{Tr_o}{J}$.
• De schuifspanning op een bepaalde radius r kan berekend worden met $\tau = \dfrac{Tr}{J}$.

Draaihoek

• De draaihoek $(\theta)$ kan worden berekend met de formule: $\theta = \dfrac{TL}{JG}$, waarbij L de lengte van de as is en de hoek in radialen wordt weergegeven.

Tekenconventie

• Gebruik voor het draaimoment de rechterhandregel; als de duim naar buiten wijst, weg van de doorsnede, is het draaimoment positief.
• Gebruik voor de draaihoek de rechterhandregel; als de duim naar buiten wijst, weg van de doorsnede, is de draaihoek positief.

Torsie van ronde holle assen

Schuifspanning

• De maximale schuifspanning wordt berekend met: $\tau_{max} = \dfrac{Tr_o}{J}$.
• De minimale schuifspanning wordt berekend met: $\tau_{min} = \dfrac{Tr_i}{J}$, waarbij $r_o$ de buitenste straal is en $r_i$ de binnenste straal.

Polair traagheidsmoment

• Het pooltraagheidsmoment J voor een holle as wordt berekend met: $J = \dfrac{\pi}{2} (r_o^4 - r_i^4)$
• Met de diameters: $J = \dfrac{\pi}{32} (D_o^4 - D_i^4)$, waarbij $D_o$ de buitendiameter is en $D_i$ de binnendiameter.

Draaihoek

• De draaihoek $(\theta)$ wordt berekend met: $\theta = \dfrac{TL}{JG}$.

Statisch onbepaalde torsie-elementen

1. Evenwicht
2. Compatibiliteit
3. Relatie draaimoment-draaiing

Neurale netwerken en diep leren

Introductie tot diep leren

• Een neuraal netwerk start met logistieke regressie.

Voorbeeld: Voorspelling van huizenprijzen

• Invoer: Huisgrootte
• Uitvoer: Prijs

Andere voorbeelden

• Reclame, beeldherkenning, zelfrijdende auto's en gebarentaal.

Waarom diep leren zo snel opkomt

• De schaal drijft de vooruitgang van diep leren.
  • Data
  • Rekenkunde
  • Algoritmen

Neurale netwerk basisprincipes

Binaire classificatie

• Bijv. kattenherkenning
  • Invoer: Afbeelding
  • Uitvoer: 0 of 1 (0: geen kat, 1: kat)

Notatie

• $(x, y)$: invoer, uitvoer paar.
• $x \in R^{n_x}$: invoerkenmerken.
• $y \in {0, 1}$: label (0 of 1).
• $m$: aantal training voorbeelden.
• $(x^{(i)}, y^{(i)})$ is het $i^{de}$ training voorbeeld.
• $X = [x^{(1)}, x^{(2)}, \dots, x^{(m)}]$
• $Y = [y^{(1)}, y^{(2)}, \dots, y^{(m)}]$

Logistische regressie

• De uitvoer $\hat{y}$ is een kans.
  • $\hat{y} = P(y = 1 \mid x)$
  • $x \in R^{n_x}$
  • Parameters: $w \in R^{n_x}$, $b \in R$
  • Uitvoer: $\hat{y} = w^T x + b$
• Sigmoid functie
  • $\sigma(z) = \frac{1}{1 + e^{-z}}$

Kostenfunctie voor logistische regressie

• Verlies (fout) functie
  • $L(\hat{y}, y) = \frac{1}{2} (\hat{y} - y)^2$ $\rightarrow$ Niet-convex
  • $L(\hat{y}, y) = -(y\log(\hat{y}) + (1 - y)\log(1 - \hat{y}))$
    • als $y = 1$: $L = -\log(\hat{y})$, we willen $\log(\hat{y})$ groot hebben, we willen $\hat{y}$ groot hebben
    • als $y = 0$: $L = -\log(1 - \hat{y})$, we willen $\log(1 - \hat{y})$ groot hebben, we willen $\hat{y}$ klein hebben
• Kostenfunctie
  • $J(w, b) = \frac{1}{m} \sum_{i=1}^{m} L(\hat{y}^{(i)}, y^{(i)})$
  • $J(w, b) = \frac{1}{m} \sum_{i=1}^{m} -(y^{(i)}\log(\hat{y}^{(i)}) + (1 - y^{(i)})\log(1 - \hat{y}^{(i)}))$

Gradiënt afdaling

• Herhaal {
  • $w := w - \alpha \frac{\partial J(w, b)}{\partial w}$
  • $b := b - \alpha \frac{\partial J(w, b)}{\partial b}$
  • }

Afgeleiden

Meer voorbeelden van afgeleiden

Berekeningsgrafiek

• $J(a, b, c) = 3(a + bc)$
  • $u = bc$
  • $v = a + u$
  • $J = 3v$

Afgeleiden met een berekeningsgrafiek

Gradiënt afdaling voor logistische regressie

• $\hat{y} = \sigma(w^T x + b)$
• $L(a, y) = - (y\log(a) + (1 - y)\log(1 - a))$

Gradiënt afdaling op m voorbeelden

• $J(w, b) = \frac{1}{m} \sum_{i=1}^{m} L(a^{(i)}, y^{(i)})$
• $\frac{\partial}{\partial w_1} J(w, b) = \frac{1}{m} \sum_{i=1}^{m} \frac{\partial}{\partial w_1} L(a^{(i)}, y^{(i)})$

Vectorisatie

• $z = w^T x + b$
• Niet-gevectoriseerde implementatie:

  z = 0
  for i in range(nx):
      z += w[i] * x[i]
  z += b
  

• Gevectoriseerde implementatie:

  z = np.dot(w, x) + b
  

Meer voorbeelden van vectorisatie

Vectorisatie van logistische regressie

• $z^{(i)} = w^T x^{(i)} + b$
• $a^{(i)} = \sigma(z^{(i)})$
• $dw = 0$
• $db = 0$
• $J = 0$

Niet-gevectoriseerde implementatie

for i in range(m):
    z[i] = np.dot(w.T, X[:,i]) + b
    A[i] = sigmoid(z[i])
    J += - (Y[0,i]*np.log(A[0,i]) + (1 - Y[0,i])*np.log(1 - A[0,i]))
    dz[i] = A[0,i] - Y[0,i]
    dw += X[:,i] * dz[i]
    db += dz[i]
J = J/m
dw = dw/m
db = db/m

Gevectoriseerde implementatie

Z = np.dot(w.T, X) + b
A = sigmoid(Z)
dZ = A - Y
dW = np.dot(X, dZ.T)/m
db = np.sum(dZ)/m
J = -np.sum(Y*np.log(A) + (1 - Y)*np.log(1 - A))/m

Vectorisatie van de gradiënt uitvoer van logistische regressie

Broadcasting in python

Een opmerking over python/numpy vectoren

Uitleg van de kostenfunctie van logistische regressie (optioneel)

Algoritmische efficiëntie

• Bij het oplossen van een probleem zoeken we over het algemeen naar het meest efficiënte algoritme om het op te lossen. "Efficiënt" betekent dat we kijken naar bronnen zoals:
  • De hoeveelheid tijd die nodig is om tot het antwoord te komen, of
  • De hoeveelheid geheugen (ruimte) die wordt gebruikt.
• De middelen die we nodig hebben, hangen af van de grootte van de invoer: het zoeken naar een naam in een telefoonboek met 10 namen is veel sneller dan het zoeken naar een naam in een telefoonboek met 10 miljoen namen.

Algemeen

• Definitie: "De efficiëntie van een algoritme hangt af van hoe het bronnengebruik van het algoritme groeit naarmate de invoergrootte groeit."
• We zullen ons richten op de hoeveelheid tijd die nodig is om een algoritme uit te voeren. De tijd die nodig is, hangt af van het aantal elementaire bewerkingen dat een algoritme uitvoert. Elementaire bewerkingen zijn over het algemeen machine-instructies (optellen, aftrekken, opslaan, laden, enz.), maar we kunnen ook hoogwaardige elementaire bewerkingen definiëren (het vergelijken van twee namen, enz.)

Worst-Case analyse

• Omdat het aantal uitgevoerde elementaire bewerkingen kan verschillen voor verschillende invoer van dezelfde grootte, beschouwen we over het algemeen de "worst-case" complexiteit, wat het maximale aantal elementaire bewerkingen is dat wordt uitgevoerd op elke invoer van grootte "n".

Asymptotische notatie

• We gebruiken de volgende notatie om de efficiëntie van een algoritme weer te geven:

Big-O notatie

• $f(n) = O(g(n))$ betekent dat $f(n) \le c \cdot g(n)$ voor een bepaalde constante c en alle voldoende grote n.
• Losjes gezegd betekent $f(n) = O(g(n))$ dat $f(n)$ niet sneller groeit dan $g(n)$.
• Voorbeeld:
  • $f(n) = 3n^2 + 100n + 5 = O(n^2)$ omdat $3n^2 + 100n + 5 \le 4n^2$ voor alle $n \ge 100$.

Big-Omega notatie

• $f(n) = \Omega(g(n))$ betekent dat $f(n) \ge c \cdot g(n)$ voor een bepaalde constante c en alle voldoende grote n.
• Losjes gezegd betekent $f(n) = \Omega(g(n))$ dat $f(n)$ niet langzamer groeit dan $g(n)$.
• Voorbeeld:
  • $f(n) = 3n^2 + 100n + 5 = \Omega(n^2)$ omdat $3n^2 + 100n + 5 \ge 3n^2$ voor alle $n \ge 1$.

Big-Theta notatie

• $f(n) = \Theta(g(n))$ betekent dat $f(n) = O(g(n))$ en $f(n) = \Omega(g(n))$.
• Losjes gezegd betekent $f(n) = \Theta(g(n))$ dat $f(n)$ in hetzelfde tempo groeit als $g(n)$.
• Voorbeeld:
  • $f(n) = 3n^2 + 100n + 5 = \Theta(n^2)$ omdat $f(n) = O(n^2)$ en $f(n) = \Omega(n^2)$.

Algemene algorithme efficiënties

• Hier zijn enkele algemene efficiënties van algoritmen, gerangschikt van snelste naar langzaamste:

• Bij het kiezen van een algoritme geven we over het algemeen de voorkeur aan algoritmen met een langzamere groeisnelheid.