{ "source_file": "0930", "source_platform": "Hashnode", "author": "Tharun", "title_listed": "How Matrix Multiplication Powers Face Recognition, ChatGPT & Self-Driving Cars", "keywords": "", "domain": "图像处理", "content_type": "深度技术解析", "is_paid_flag": "否", "url": "https://tharunpandya.hashnode.dev/matrix-multiplication-transpose-dot-product", "publish_date": "2026-07-19", "corpus_stage": "", "notes": "", "id": "27ea62dbe042", "collected_at": "2026-10-02T14:10:46", "title": "Matrix Multiplication, Transpose & Dot Product", "body_markdown": "How Matrix Multiplication Powers Face Recognition, ChatGPT & Self-Driving Cars\nUpdated\nJuly 22, 2026\n•\n24\nmin read\n•\nView as Markdown\nT\nTharun\nTry this for a second. Close your eyes, and have someone toss a small ball gently towards you. Try to catch it.\nSomehow, without doing any conscious \"calculation,\" your brain combined information from your eyes (where is the ball, how fast is it moving), your inner ear (which way is up, are you balanced), and your memory of every ball you've ever caught before — and blended all of that into one single decision: move your hand exactly\nhere\n, exactly\nnow\n.\nOne important thing happened here. Your brain did not treat every piece of information the same. For example, if the lighting was poor, your brain trusted what your eyes saw a little less. At the same time, it relied more on what it already knew from past experience, like how balls usually fall. Instead of simply adding all the information together, your brain gave more importance to the signals it trusted the most in that moment. Then it combined those signals to make one final decision.\nThat exact idea — take several pieces of information, give each one an importance (\"weight\"), and combine them into one new answer — is the single most important mathematical operation in all of Machine Learning. It's called\nmatrix multiplication\n, and once you genuinely understand it, you'll start seeing it everywhere: in how your phone recognizes your face, in how Google Translate decides which words matter most in a sentence, and in literally every layer of every neural network ever built, including the one powering ChatGPT.\nIn the last blog, we learned addition, subtraction, and a \"spotlight-style\" multiplication that only ever compares matching positions, one at a time, never letting numbers from different rows or columns mix together. Today, we're breaking that limit completely. Get ready — this is the operation everything else in Machine Learning is quietly built on top of.\nBy the end of this blog, you will understand:\nWhat a\ndot product\nis, explained with tiny numbers, before we touch a matrix at all\nWhat matrix multiplication actually does, step by step, by hand\nExactly how it's different from the \"spotlight\" element-wise multiplication from last time — and why mixing the two up breaks real projects\nWhat\ntranspose\nis, and why you'll type\n.T\nconstantly to make matrix multiplication even possible\nWhat\ncross product\nis, and where it quietly makes AR filters and 3D graphics look realistic\nReal, specific, low-level examples from face recognition, translation apps, and camera filters\nTake your time with this one. Everything from here on in the entire Machine Learning world is built on this idea.\nPart 1: Understanding \"Dot Product\" First (Before Matrices, With Tiny Numbers)\nLet's not jump straight into matrices. Let's understand the tiny building block first, using an example you can genuinely picture.\nImagine you're a school teacher grading a student's final score for the term. There were three tests, and each one counts for a different amount towards the final grade:\nTest\nStudent's score (out of 100)\nHow much this test counts (its \"weight\")\nTest 1\n80\n0.2 (worth 20% of the final grade)\nTest 2\n90\n0.3 (worth 30% of the final grade)\nTest 3\n70\n0.5 (worth 50% of the final grade)\nTo find the final grade, you don't just average the three scores equally. You multiply each score by its own weight, and then\nadd up\nall three results:\nfinal_grade = (80 × 0.2) + (90 × 0.3) + (70 × 0.5)\nfinal_grade = 16 + 27 + 35\nfinal_grade = 78\nThat's it. That entire process — multiply matching pairs of numbers, then add up all the results into one single number — is called a\ndot product\n. It's the single most repeated tiny calculation in the whole of Machine Learning, and you just did it by hand, using nothing more complicated than a school report card.\nHere's the important realization:\nmatrix multiplication is nothing but doing this exact dot-product calculation, over and over, for every row of one matrix against every column of another.\nIf you understood the report card example above, you already understand matrix multiplication. You just haven't seen it dressed up in matrix notation yet. Let's fix that now.\nPart 2: Matrix Multiplication — Weighing and Combining, at Scale\nSetting Up the Idea\nLet's slightly extend the report card example. Imagine now you're not grading one student — you're grading three students at once, and there are two different \"final grade formulas\" you want to apply to all of them (say, one formula for an overall grade, and one formula for a \"college readiness\" score, each weighing the three tests differently).\nInstead of writing out the same calculation nine separate times by hand (3 students × essentially each getting graded against 2 formulas is actually going to give us 3×2 = 6 answers, but let's build it properly), we organize this into two grids:\nStudents' scores (3 students, 3 tests each):\n\n Test1 Test2 Test3\nStudent1 80 90 70\nStudent2 60 75 95\nStudent3 85 65 80\n\n\nWeight formulas (3 tests, 2 formulas):\n\n Formula1(Overall) Formula2(College-Readiness)\nTest1 0.2 0.4\nTest2 0.3 0.1\nTest3 0.5 0.5\nNotice something already: the \"scores\" grid has\n3 columns\n(one per test), and the \"weights\" grid has\n3 rows\n(also one per test). They match up — 3 and 3. This is not a coincidence, and remembering this exact detail is the single most important rule of matrix multiplication.\nTo multiply matrix A by matrix B, the number of columns in A must equal the number of rows in B.\nA: (3 students x 3 tests) B: (3 tests x 2 formulas)\n └────┬────┘\n these must match\n\nResult shape: (3 students x 2 formulas)\nIf they don't match — say, if your scores grid had 3 tests but your weights grid only had data for 2 tests — the multiplication is not just \"wrong.\" It's genuinely undefined. There's no meaningful way to do it, because there'd be a test with no weight to pair up with. NumPy, sensibly, will refuse to run it and give you an error instead of a wrong answer.\nDoing It By Hand, Fully, One Cell at a Time\nLet's compute Student 1's\nOverall grade\n(Formula 1) by hand, using exactly the dot-product idea from Part 1.\nStudent 1's row:\n80, 90, 70\nFormula 1's column:\n0.2, 0.3, 0.5\n(80 × 0.2) + (90 × 0.3) + (70 × 0.5)\n= 16 + 27 + 35\n= 78\nNow Student 1's\nCollege-Readiness grade\n(Formula 2), using the same row, but the\nother\ncolumn this time:\nStudent 1's row:\n80, 90, 70\nFormula 2's column:\n0.4, 0.1, 0.5\n(80 × 0.4) + (90 × 0.1) + (70 × 0.5)\n= 32 + 9 + 35\n= 76\nNotice: Student 1's row got reused twice — once against each column. That's exactly how matrix multiplication works. Every row from the first matrix gets multiplied, dot-product style, against\nevery\ncolumn of the second matrix, one pairing at a time.\nIf we did this for all 3 students against both formulas, we'd end up with a brand new grid — 3 rows (one per student), 2 columns (one per formula):\nResult = 78 76\n ... ...\n ... ...\n(We've only fully worked out the first row here by hand, purely to keep this section readable — but the process for Student 2 and Student 3 is identical: take their row, pair it against each column, dot-product style.)\nThe General Rule, Written Simply\nresult[row][column] = sum over every test of ( scores[row][test] × weights[test][column] )\nOr, in the more common notation you'll see in textbooks and code:\nresult[i][j] = sum over k of A[i][k] × B[k][j]\nDon't be scared by the letters\ni\n,\nj\n,\nk\n— they're just labels.\ni\nmeans \"which row we're currently building,\"\nj\nmeans \"which column we're currently building,\" and\nk\nis the counter that walks along the row and down the column at the same time, multiplying matching pairs and adding them up — exactly like our report card dot product.\nNow, the Python Code\nimport numpy as np\n\nx = np.random.randn(3, 6) # imagine: 3 rows, 6 columns\ny = np.random.randn(6, 4) # imagine: 6 rows, 4 columns — notice 6 matches 6!\n\nresult = np.zeros((3, 4)) # the result will be 3 rows, 4 columns\n\nfor i in range(len(x)): # walk through every row of x\n for j in range(len(y[0])): # walk through every column of y\n for k in range(len(y)): # walk along the row of x, and down the column of y, together\n result[i, j] += x[i, k] * y[k, j]\n\nprint(result)\nNotice this code needs\nthree\nnested loops, not two like addition and subtraction needed. That's a strong, honest signal that this operation is doing meaningfully more work — for every single answer in the result grid, it's now doing an entire dot-product calculation (multiply several pairs, then add them all up), not just one lonely multiplication like element-wise multiplication did.\nThe line\nresult[i, j] += x[i, k] * y[k, j]\nis worth reading slowly. The\n+=\nsymbol means \"add this new amount to whatever is already in\nresult[i, j]\n, don't overwrite it.\" So as\nk\ncounts up (0, then 1, then 2, and so on), we keep multiplying the next pair and adding it onto our running total — exactly the way we manually added\n16 + 27 + 35\nin our report card example.\nThe Shortcut Version\nprint(np.dot(x, y))\nprint(np.matmul(x, y))\nBoth give the exact same answer. In most real projects, you'll see either\nnp.matmul(x, y)\n, or simply\nx @ y\n— the\n@\nsymbol is Python's shorthand specifically for real matrix multiplication, precisely so it never gets confused with the plain\n*\nsymbol, which (as you learned last blog) means something completely different.\nThe Comparison You Need Tattooed on Your Brain\nThis is, genuinely, one of the single most common beginner mistakes in the entire field. Let's make sure it never trips you up.\nElement-wise multiplication (\nA * B\n)\nMatrix multiplication (\nA @ B\n,\nnp.matmul\n,\nnp.dot\n)\nShapes required\nBoth matrices must be the exact same size\nColumns of A must equal rows of B — sizes can otherwise be totally different\nWhat happens for one answer\nOne number times one number, same position, nothing else involved\nAn entire row multiplied against an entire column, then all those pairs are added up\nSize of the result\nSame size as the original matrices\nRows of A by columns of B — often a completely different shape than either original matrix\nThe \"story\" behind it\n\"Keep this position, or wipe it out\" — like a spotlight or a stencil\n\"Weigh up many pieces of information and combine them into something new\" — like a final grade, or a decision\nEveryday examples\nInstagram filters, video call background masks, hiding \"future\" words during translation\nFace recognition comparisons, neural network layers, translation model attention, self-driving car sensor fusion\nIf you remember only one sentence from this entire blog, make it this one:\nElement-wise multiplication decides what survives, position by position. Matrix multiplication creates something genuinely new, by weighing and combining lots of numbers into one.\nPart 3: Where Matrix Multiplication Actually Shows Up (Real, Concrete Examples)\n1. Face recognition — comparing \"faceprints\" (Computer Vision)\nHere's something that will probably surprise you. Modern face recognition systems (the kind used in Face ID, or in airport security gates) don't actually compare photos pixel by pixel. Instead, they first convert your face into something called an\nembedding\n— a list of, say, 128 numbers that captures the \"essence\" of your face (things like the general shape of your jawline, the spacing of your eyes, and hundreds of other subtle patterns no human could easily describe in words).\nTo check \"does this new face match the owner's registered face,\" the system needs to measure how similar two of these 128-number lists are. It does this using a calculation built directly on the dot product you learned in Part 1 — essentially matrix multiplication between these embedding lists. A high similarity score (a big combined number) means \"these are very likely the same face.\" A low score means \"these are likely two different people.\"\nHere's the number that should genuinely surprise you: your phone runs this exact comparison — a dot product across 128 numbers — in a tiny fraction of a second, and it does it every single time you glance at your phone to unlock it. That's matrix multiplication, quietly guarding your phone, dozens of times a day.\n2. Self-driving cars combining and reasoning about sensor readings\nIn the last blog, we saw self-driving cars\nadding\nsensor readings together to reinforce weak signals. But real systems go further — they don't trust every sensor equally in every situation. A radar sensor might be far more reliable in heavy rain than a camera, but a camera is far more reliable for reading actual road signs. The car's software learns (again, \"learns\" — a topic for later blogs, don't worry about it yet) how much to\nweigh\neach sensor's input in different conditions, and combines all these weighted readings using matrix multiplication — the exact same \"report card\" idea from Part 1, just with sensor readings instead of test scores, and \"trust levels\" instead of grading weights.\n3. Google Translate and Transformers — deciding \"which words matter to which\" (NLP)\nThis is genuinely one of the most important real-world uses of matrix multiplication in existence today, so let's slow right down.\nWhen a modern translation model (or ChatGPT, or any similar \"Transformer\" model — we'll dedicate a proper future blog to fully unpacking this name) processes the sentence \"The cat sat on the mat because it was tired,\" it needs to figure out something tricky: does the word \"it\" refer to \"the cat\" or \"the mat\"?\nTo figure this out, every word in the sentence is converted into two different lists of numbers, called a\nQuery\nand a\nKey\n(again — don't worry about memorizing these names right now, just follow the idea). Roughly speaking, the \"Query\" for the word \"it\" gets compared against the \"Key\" for every other word in the sentence, using — you guessed it — matrix multiplication. Words that are more relevant to \"it\" (like \"cat,\" because cats get tired, unlike mats) end up with a higher combined number, meaning the model should pay more \"attention\" to that word when deciding what \"it\" means.\nThis process is genuinely called \"attention\" in the Transformer architecture, and it is, at its mathematical core, exactly the matrix multiplication you learned to do by hand in Part 2 of this blog — just done for every word against every other word, for every sentence, at a staggering scale.\nHere's the number that should genuinely shock you. A single, ordinary sentence being translated can involve\nmillions\nof these tiny multiply-and-add calculations, happening across enormous grids of numbers, and modern translation apps still return your translated sentence to you in under a second. Every single \"instant\" translation you've ever gotten on your phone secretly involved a scale of arithmetic that would take a human with a calculator, working non-stop, an entire lifetime to complete by hand.\nPart 4: Transpose — Flipping the Table on Its Side\nThe Problem That Forces This Idea to Exist\nHere's a very real, very common situation you'll run into the moment you start actually building things.\nRemember our attention example above — comparing a word's \"Query\" against every other word's \"Key\"? Let's say each word's Query and Key are stored as a list of, say, 4 numbers each. If you have 6 words in your sentence, your Query grid is (6 rows, 4 columns), and your Key grid is also (6 rows, 4 columns).\nNow try to apply our golden rule: to multiply Query by Key, the columns of Query (which is 4) must match the rows of Key (which is 6). They don't match — 4 and 6 are different numbers. Multiplication is blocked, even though we desperately need this comparison to happen.\nThe fix isn't to change your actual data. The fix is to\nflip one of the grids on its side\n— turn every row into a column, and every column into a row. A (6, 4) grid, flipped this way, becomes a (4, 6) grid. Now, suddenly, columns of Query (4) match rows of the\nflipped\nKey (4). Multiplication becomes possible, and it gives us exactly the \"who should pay attention to whom\" comparison we needed.\nThis flipping operation is called\ntranspose\n.\nThe Rule\nIf A has shape (rows, columns), then A transpose (written Aᵀ) has shape (columns, rows)\nAᵀ[column][row] = A[row][column]\nIn plain English: whatever number used to be at row 2, column 5 is now sitting at row 5, column 2. Every number keeps its exact value — only its\nposition\nchanges.\nDoing It By Hand\nMatrix A (2 rows, 3 columns) =\n\n 1 2 3\n 4 5 6\nTransposing it flips rows into columns. The first row (\n1, 2, 3\n) becomes the first column. The second row (\n4, 5, 6\n) becomes the second column.\nMatrix Aᵀ (3 rows, 2 columns) =\n\n 1 4\n 2 5\n 3 6\nNothing was calculated. Nothing was added or multiplied. We simply re-arranged the same exact numbers into a new orientation.\nPython Code\nimport numpy as np\n\nmat_A = np.random.randn(12, 4)\n\n# transpose — the manual, honest way\nmat_A_T = np.zeros((4, 12))\nfor i in range(mat_A.shape[0]):\n for j in range(mat_A.shape[1]):\n mat_A_T[j, i] = mat_A[i, j]\n\nprint(mat_A_T)\n# the shortcut\nprint(mat_A.T)\n\n# proving both give exactly the same result\nprint((mat_A.T == mat_A_T).all())\n# True\nNotice the very simple pattern in the manual loop: we're just placing\nmat_A[i, j]\ninto the\nopposite\nposition,\nmat_A_T[j, i]\n. Row and column literally swap places for every single number.\nWhere Transpose Actually Shows Up (Real, Concrete Examples)\n1. Making the Query and Key comparison in Transformers actually possible (NLP)\nExactly as described above — nearly every \"attention\" calculation inside translation apps and chatbots involves transposing the Key grid before multiplying it against the Query grid, purely to make the shapes line up correctly. Without transpose, this entire mechanism — arguably the single biggest breakthrough behind modern AI language tools — simply couldn't be computed.\n2. Comparing two faces' embeddings the right way round (Computer Vision)\nWhen comparing one face's 128-number embedding against a\ndatabase\nof thousands of other registered faces (say, at an airport immigration gate), the incoming face's embedding often needs to be transposed so its shape correctly lines up against the entire stored database grid, letting one single matrix multiplication compare the new face against every stored face at once, instead of one at a time in a slow loop.\n3. Rotating and repositioning objects in photo and video editing apps\nWhen an app rotates or repositions a detected object (say, straightening a tilted photo, or repositioning a detected face for a filter), the underlying coordinate grids describing \"where is every point of this object\" frequently need to be transposed at some stage, purely to keep the maths of the rotation lined up correctly with the multiplication being applied.\nTranspose never changes your actual data or its meaning. It only changes the\norientation\nyou're looking at it from — but as you can see above, that one small change is very often the exact difference between a calculation that's possible, and one that simply cannot run at all.\nPart 5: Cross Product — A Strange, Special Kind of Multiplication, Just for 3D\nThe Story\nEverything we've covered so far takes numbers and combines them into other numbers. Cross product does something genuinely different, and honestly, a little strange the first time you meet it — it takes two arrows (vectors) pointing in 3D space, and produces a\nbrand new arrow, pointing in a completely different direction\n, one that is perfectly perpendicular (at a right angle) to both of the original two.\nHere's a low-level example that should make this click immediately: think about how AR face filters (the kind Snapchat and Instagram use to put digital sunglasses, animal ears, or makeup onto your real face) manage to make the digital object look like it's genuinely sitting on your face, with lighting that matches the real room you're in.\nYour face, inside these apps, gets mapped as a mesh made of tiny triangles (imagine covering your whole face with hundreds of tiny flat triangular patches). For the lighting on a digital pair of sunglasses to look convincing — brighter where a window's light hits it, darker in shadowed areas — the app needs to know, for every single tiny triangle, which direction that triangle is \"facing.\" This facing direction is called a\nsurface normal\n, and it is calculated, for every one of those hundreds of triangles, using cross product — taking two edges of the triangle (each one a simple 3D arrow) and finding the one new arrow that points straight out of the triangle's face.\nGet this right for hundreds of tiny triangles, dozens of times a second, and a flat digital object convincingly looks like it's really sitting on your real, three-dimensional face, lit by your real room. Get it wrong, and the filter looks flat, fake, and oddly lit — exactly the \"uncanny\" look you've probably noticed in a cheap or badly-made filter.\nThe Rule\nFor two 3D vectors A and B (each one simply a list of 3 numbers, representing a direction and length in 3D space):\ncross_product[0] = A[1]×B[2] − B[1]×A[2]\ncross_product[1] = A[2]×B[0] − B[2]×A[0]\ncross_product[2] = A[0]×B[1] − B[0]×A[1]\nDon't worry about memorizing this formula by heart — almost nobody in industry does it by hand. What matters is understanding\nwhat it produces\n: one new arrow, always perfectly perpendicular to both of the arrows you started with. This only really makes sense in 3D, which is why cross product only applies to 3D vectors — it's a fundamentally geometric idea about physical space, not a general-purpose way to combine any kind of data, unlike everything else in this series so far.\nPython Code\nimport numpy as np\n\nA = np.array([[1], [2], [3]])\nB = np.array([[4], [5], [6]])\n\ncross_product = np.zeros((3, 1))\n\nfor i in range(A.shape[0]):\n if i == A.shape[0] - 1:\n cross_product[i] = (A[i] * B[0]) - (B[i] * A[0])\n else:\n cross_product[i] = (A[i] * B[i + 1]) - (B[i] * A[i + 1])\n\nprint(cross_product)\n[[-3.]\n [-3.]\n [ 6.]]\nYou can double-check this using NumPy's built-in shortcut:\nnp.cross(A.flatten(), B.flatten())\ngives you the exact same result.\nWhere Cross Product Actually Shows Up (Real, Concrete Examples)\nLet's be genuinely honest here — this is the one operation in the whole series that's less common in \"everyday\" Machine Learning (like recommendation systems or basic classification), but it becomes essential the moment your work touches anything physical or visual in three dimensions.\nUse case\nWhat cross product does there\nAR/VR face filters and 3D games\nCalculates which direction each tiny surface triangle faces, so lighting on digital objects looks realistic\nSelf-driving cars reading road surfaces (LIDAR processing)\nHelps determine the tilt and orientation of the road surface from a cloud of distance measurements, so the car understands slopes, bumps, and curves correctly\nRobotics (robot arms, drones)\nCalculates rotation direction and torque — essentially, \"which way should this joint twist\"\nPose estimation apps (fitness apps that track your form, like a squat-counter app)\nHelps determine the exact 3D orientation of your limbs and joints from camera data, checking your form against a correct posture\nIf you're building a chatbot, a spam filter, or a basic recommendation system, you may genuinely never write\nnp.cross\nyourself. But the instant your work touches a camera capturing the real 3D world, cross product is very likely quietly running underneath, deciding which way things are facing.\nPart 6: Everything From This Blog, Side by Side\nOperation\nInput shapes\nOutput shape\nThe one-line idea\nElement-wise multiplication\nSame shape required\nSame shape\nKeep or wipe out, position by position\nMatrix multiplication\nColumns of A = rows of B\nRows of A by columns of B\nWeigh and combine many numbers into something new\nTranspose\nAny shape (rows, columns)\n(columns, rows)\nFlip orientation, no data lost or changed\nCross product\nTwo 3D vectors (lists of 3 numbers)\nOne new 3D vector\nFind a fresh direction, perpendicular to both original ones\nPart 7: Why This Should Genuinely Impress You\nGo back to the ball-catching example from the very start of this blog. Your brain, in real time, combined visual information, balance information, and years of memory, and it\nweighed\neach of these differently depending on the situation — trusting your eyes more in good light, trusting muscle memory more in the dark.\nWe now know, in cold, precise mathematical terms, exactly how a computer can be made to do something structurally similar: multiply each piece of information by how much it should be trusted (its \"weight\"), and add all those weighted pieces together — a dot product, repeated across an entire grid, which is exactly what matrix multiplication is.\nHere is the genuinely humbling part, worth sitting with for a moment. Every time you glance at a friend's face across a room and instantly know who they are, or catch a word someone says despite background noise, or reach out and catch a tossed ball without thinking — your brain is running a process that, mathematically, resembles millions of these dot-product-style weighings, happening through biological neurons instead of numbers in a grid, in a fraction of a second, using less power than a dim lightbulb.\nThe version we've built out of matrix multiplication — the one running inside your phone's Face ID, inside Google Translate, inside a self-driving car's cameras — needs enormous, purpose-built chips, consuming meaningfully more electricity, just to imitate a small sliver of what your brain does constantly, quietly, without you ever noticing the \"calculation\" happening at all. Understanding this math doesn't just help you build Machine Learning systems. It genuinely gives you a small window into just how extraordinary your own brain's ordinary, everyday moments really are.\nWhat's Coming Next\nYou now know how to combine matrices, weigh and merge them through real matrix multiplication, reorient them with transpose, and even find fresh directions in 3D space with cross product. But there's a question we've been quietly avoiding this entire series, and it's finally time to answer it:\nWhen you multiply a vector by a matrix, what actually happens to that vector — geometrically? Does it move? Does it get squashed? Can you always get back to where you started?\nIt turns out every single matrix multiplication is secretly\nmoving\nyour data — stretching it, rotating it, sometimes even squashing it flat and destroying information permanently. That idea is called a\nlinear transformation\n, and understanding it is what finally makes concepts like \"the model is learning a representation\" or \"PCA reduces dimensions\" click into place, intuitively, instead of just being phrases you nod along to.\nTo fully understand linear transformation properly, we need two more tools first: the\ndeterminant\n, which tells you whether a transformation destroys information forever, and the\nmatrix inverse\n, which tells you exactly how to undo a transformation, if it can be undone at all.\nThat's exactly where the next blog picks up — and I promise, it's going to make the phrase \"the model is learning\" finally make real sense.\nSee you there.\n#\nai\n#\nmachine-learning\n#\nlinear-algebra\n#\nmatrix\n#\nmath\n#\ncomputer-vision\n#\nnlp\n#\nbeginners\n#\npython\n#\nnumpy\n#\ndata-science\n#\ndeeplearning\n13\nviews", "metadata": { "title": "Matrix Multiplication, Transpose & Dot Product", "description": "Learn matrix multiplication, dot product, transpose, and cross product with simple examples, Python code, and real Machine Learning applications.", "keywords": null, "author": null, "og:title": "Matrix Multiplication, Transpose & Dot Product", "og:description": "Learn matrix multiplication, dot product, transpose, and cross product with simple examples, Python code, and real Machine Learning applications.", "og:url": "https://tharunpandya.hashnode.dev/matrix-multiplication-transpose-dot-product", "og:site_name": "Machine Learing From scratch", "og:image": "https://cdn.hashnode.com/uploads/og-images/6a3f9a25a837e83b51cc8712/bacc5c1b-456d-438c-9b76-4d5f2039ef1d.jpg", "og:image:width": "1200", "og:image:height": "630", "og:type": "article", "twitter:card": "summary_large_image", "twitter:title": "Matrix Multiplication, Transpose & Dot Product", "twitter:description": "Learn matrix multiplication, dot product, transpose, and cross product with simple examples, Python code, and real Machine Learning applications.", "twitter:image": "https://cdn.hashnode.com/uploads/og-images/6a3f9a25a837e83b51cc8712/bacc5c1b-456d-438c-9b76-4d5f2039ef1d.jpg", "article:published_time": "2026-07-19T04:26:35.097Z", "article:modified_time": "2026-07-22T12:18:52.076Z", "article:author": "https://tharunpandya.hashnode.dev/@tharun-pandya" }, "paywall": { "listed_paid": false, "detected": false, "marker": "", "public_only": false, "policy": "付费/会员内容只保留页面公开可见部分，不绕过付费墙" }, "crawl": { "success": true, "status_code": 200, "error": "" }, "code_blocks": [ { "file": "attachments/27ea62dbe042/code/body-000.txt", "chars": 95, "language": "text" }, { "file": "attachments/27ea62dbe042/code/body-001.txt", "chars": 414, "language": "text" }, { "file": "attachments/27ea62dbe042/code/body-002.txt", "chars": 172, "language": "text" }, { "file": "attachments/27ea62dbe042/code/body-003.txt", "chars": 57, "language": "text" }, { "file": "attachments/27ea62dbe042/code/body-004.txt", "chars": 56, "language": "text" }, { "file": "attachments/27ea62dbe042/code/body-005.txt", "chars": 65, "language": "text" }, { "file": "attachments/27ea62dbe042/code/body-006.txt", "chars": 91, "language": "text" }, { "file": "attachments/27ea62dbe042/code/body-007.txt", "chars": 48, "language": "text" }, { "file": "attachments/27ea62dbe042/code/body-008.txt", "chars": 522, "language": "text" }, { "file": "attachments/27ea62dbe042/code/body-009.txt", "chars": 43, "language": "text" }, { "file": "attachments/27ea62dbe042/code/body-010.txt", "chars": 121, "language": "text" }, { "file": "attachments/27ea62dbe042/code/body-011.txt", "chars": 64, "language": "text" }, { "file": "attachments/27ea62dbe042/code/body-012.txt", "chars": 66, "language": "text" }, { "file": "attachments/27ea62dbe042/code/body-013.txt", "chars": 237, "language": "text" }, { "file": "attachments/27ea62dbe042/code/body-014.txt", "chars": 116, "language": "text" }, { "file": "attachments/27ea62dbe042/code/body-015.txt", "chars": 123, "language": "text" }, { "file": "attachments/27ea62dbe042/code/body-016.txt", "chars": 325, "language": "text" }, { "file": "attachments/27ea62dbe042/code/body-017.txt", "chars": 22, "language": "text" } ], "images": [ { "status": "ok", "url": "https://cdn.hashnode.com/uploads/covers/6a3f9a25a837e83b51cc8712/6cd1e956-b487-4fe6-9615-9fc4f1c31b47.jpg", "bytes": 87171, "reused": true, "local_path": "attachments/27ea62dbe042/images/002.jpg", "src": "https://cdn.hashnode.com/uploads/covers/6a3f9a25a837e83b51cc8712/6cd1e956-b487-4fe6-9615-9fc4f1c31b47.jpg", "alt": "How Matrix Multiplication Powers Face Recognition, ChatGPT & Self-Driving Cars", "downloaded": true } ], "audio": [], "videos": [], "links": [ { "href": "https://tharunpandya.hashnode.dev/matrix-multiplication-transpose-dot-product.md", "label": "View as Markdown", "type": "a" }, { "href": "https://hashnode.com/@tharun-pandya", "label": "T", "type": "a" }, { "href": "https://linkedin.com/in/tharun-pandya-kodi", "label": "", "type": "a" }, { "href": "https://tharunpandya.hashnode.dev/tag/ai", "label": "# ai", "type": "a" }, { "href": "https://tharunpandya.hashnode.dev/tag/machine-learning", "label": "# machine-learning", "type": "a" }, { "href": "https://tharunpandya.hashnode.dev/tag/linear-algebra", "label": "# linear-algebra", "type": "a" }, { "href": "https://tharunpandya.hashnode.dev/tag/matrix", "label": "# matrix", "type": "a" }, { "href": "https://tharunpandya.hashnode.dev/tag/math", "label": "# math", "type": "a" }, { "href": "https://tharunpandya.hashnode.dev/tag/computer-vision", "label": "# computer-vision", "type": "a" }, { "href": "https://tharunpandya.hashnode.dev/tag/nlp", "label": "# nlp", "type": "a" }, { "href": "https://tharunpandya.hashnode.dev/tag/beginners", "label": "# beginners", "type": "a" }, { "href": "https://tharunpandya.hashnode.dev/tag/python", "label": "# python", "type": "a" }, { "href": "https://tharunpandya.hashnode.dev/tag/numpy", "label": "# numpy", "type": "a" }, { "href": "https://tharunpandya.hashnode.dev/tag/data-science", "label": "# data-science", "type": "a" }, { "href": "https://tharunpandya.hashnode.dev/tag/deeplearning", "label": "# deeplearning", "type": "a" } ], "retry_at": "2026-10-03T08:05:06", "repair_version": 2, "repaired_at": "2026-10-14T10:50:30Z", "source_url": "https://tharunpandya.hashnode.dev/matrix-multiplication-transpose-dot-product", "papers": [], "actual_video_files": [], "body_chars": 27644, "expected_body_images": 1, "discovery_status": "ok", "delivery_status": "ok", "missing_reason": "", "raw_html": "attachments/27ea62dbe042/pages/source.html", "local_html": "attachments/27ea62dbe042/pages/article.html", "body_base_path": "attachments/27ea62dbe042/pages/", "body_markdown_path": "attachments/27ea62dbe042/pages/article.md" }