How machine learning helps scientists find new planets, read satellite images, and keep space safe from collisions
A few years ago, if you wanted to find a new planet outside our solar system, you needed a team of astronomers staring at brightness charts for weeks. Today, a well trained model can scan thousands of stars in the time it takes to make a cup of tea.
This is not science fiction. It is already happening at ISRO, NASA, ESA, and every major space agency in the world. Space exploration produces an enormous amount of data. Satellites alone send back terabytes every single day. No team of humans, no matter how skilled, can look at all of it in time to make it useful. That is exactly the kind of problem AI is good at solving.
In this article, I want to walk through four real ways AI is used in space exploration today. For each one, I will explain the idea in plain terms and share a simple code example so you can see how it actually works, not just read about it.
The Real Problem: Too Much Data, Too Few Humans
Before AI became common in this field, most of the work was manual. Scientists would look at images pixel by pixel, or study graphs point by point, checking for anything unusual.
The problem was never a lack of effort. It was scale. A single Earth observation satellite can capture more images in a day than a team could review in a month. And when you are searching for something as small as a single dip in starlight, caused by a planet passing in front of its star, missing it by even a little means missing a discovery entirely.
AI does not replace the scientist here. It replaces the slow, repetitive scanning part of the job, so scientists can spend their time on the interesting question: what does this pattern actually mean?
Finding Exoplanets: Teaching AI to Spot a Blink
When a planet passes in front of its star, from our point of view, the star’s brightness dips slightly for a few hours, then returns to normal. This is called a transit. It happens over and over, once every orbit.
The dip is tiny, often less than one percent of the star’s total brightness. To put that in perspective, it is roughly the same as the dimming you would see if a single mosquito flew in front of a car headlight from a few meters away. Spotting that by eye, buried in a noisy signal, night after night, is genuinely hard. But it is a pattern, and patterns are exactly what machine learning is built to find.
Here is a simplified example of how you might detect a transit-like dip in a star’s brightness data using Python:
import numpy as np
from scipy.signal import find_peaks
def detect_transit_dips(time, brightness, threshold=0.01):
"""
Detects possible planet transits by looking for dips
in brightness that repeat at regular intervals.
"""
normalized = brightness / np.median(brightness)
dips = 1 - normalized
# A transit appears as a brief, repeating drop in stellar brightness.
# We search for these drops using peak detection on the inverted signal,
# so a "dip" in brightness becomes a "peak" we can measure.
peak_indices, properties = find_peaks(dips, height=threshold, distance=20)
dip_times = time[peak_indices]
dip_depths = dips[peak_indices]
return dip_times, dip_depths
# Example usage with simulated light curve data
time = np.linspace(0, 100, 5000)
brightness = np.ones_like(time) + np.random.normal(0, 0.002, len(time))
# Simulate a transit every 10 days
for t0 in np.arange(5, 100, 10):
transit_mask = np.abs(time - t0) < 0.3
brightness[transit_mask] -= 0.015
dip_times, dip_depths = detect_transit_dips(time, brightness)
print(f"Detected {len(dip_times)} possible transits")
This is a simplified version of what real pipelines do. NASA’s Kepler and TESS missions use far more advanced versions of this idea, often combined with neural networks trained on thousands of confirmed and false transit signals, so the model learns to tell a real planet apart from noise, starspots, or a passing asteroid. But the core idea is the same: look for a repeating pattern that a human eye would take too long to confirm across thousands of stars.
Reading Earth from Orbit: Satellite Image Analysis
The second big use of AI in space is pointed the other way, down at Earth instead of out at the stars.
Satellites constantly photograph the planet. Missions like Landsat, Sentinel, and India’s own Cartosat and Resourcesat capture images of nearly every part of Earth on a repeating schedule, some of them passing over the same location every few days. That data is used to track deforestation, monitor crop health, measure glacier melt, and respond to natural disasters. A single Sentinel-2 satellite alone produces enough imagery to cover the entire planet’s land surface roughly every five days. The images themselves are just pixels. AI is what turns those pixels into information, like “this forest area shrank by 12 percent this year” or “this region shows signs of drought stress.”
A common technique here is calculating a vegetation index from satellite bands. Here is a basic example using NDVI, a widely used method to measure plant health from satellite imagery:
import numpy as np
def calculate_ndvi(nir_band, red_band):
"""
Calculates NDVI (Normalized Difference Vegetation Index).
Values close to 1 mean healthy vegetation.
Values close to 0 or negative mean bare soil, water, or dead vegetation.
"""
nir = nir_band.astype(float)
red = red_band.astype(float)
denominator = nir + red
denominator[denominator == 0] = 1e-6 # avoid divide by zero
ndvi = (nir - red) / denominator
return ndvi
# Example: classify vegetation health from an NDVI map
def classify_vegetation(ndvi_map):
healthy = np.sum(ndvi_map > 0.5)
moderate = np.sum((ndvi_map > 0.2) & (ndvi_map <= 0.5))
poor = np.sum(ndvi_map <= 0.2)
total = ndvi_map.size
print(f"Healthy vegetation: {healthy/total*100:.1f}%")
print(f"Moderate vegetation: {moderate/total*100:.1f}%")
print(f"Poor or no vegetation: {poor/total*100:.1f}%")
This is a simple statistical formula, not a neural network, and that is worth pointing out. A lot of useful AI work in space science is not deep learning at all. It is a smart combination of physics, math, and data. Where deep learning adds real value is in tasks like automatically classifying land types across thousands of images, or detecting new wildfires the moment they start, tasks that would take a human analyst days to do by hand.
Autonomous Rovers: Letting AI Drive on Another Planet
Here is a problem that sounds simple until you think about it properly. Mars is, on average, about 14 light minutes away from Earth. That means a command sent from mission control takes 14 minutes to arrive, and the response takes another 14 minutes to come back. If a rover sees a rock in its path, it cannot wait 28 minutes for a human to say “turn left.”
So the rover has to think for itself, at least for small decisions. This is where AI based path planning comes in. Both Curiosity and Perseverance use a system called AutoNav, which lets the rover choose its own safe path across short distances without waiting for instructions from Earth. Thanks to this, Perseverance can now cover more ground in a single Martian day than earlier rovers managed in a week, simply because it no longer has to stop and wait for a new command every time it faces an obstacle.
A simplified version of the idea, using a basic path planning approach:
import heapq
def a_star_path(grid, start, goal):
"""
A simple A* pathfinding algorithm.
grid: 2D array where 0 = safe terrain, 1 = obstacle
start, goal: (row, col) tuples
"""
def heuristic(a, b):
return abs(a[0] - b[0]) + abs(a[1] - b[1])
rows, cols = len(grid), len(grid[0])
open_set = [(0, start)]
came_from = {}
g_score = {start: 0}
while open_set:
_, current = heapq.heappop(open_set)
if current == goal:
path = [current]
while current in came_from:
current = came_from[current]
path.append(current)
return path[::-1]
neighbors = [
(current[0]+1, current[1]), (current[0]-1, current[1]),
(current[0], current[1]+1), (current[0], current[1]-1)
]
for neighbor in neighbors:
r, c = neighbor
if 0 <= r < rows and 0 <= c < cols and grid[r][c] == 0:
tentative_g = g_score[current] + 1
if neighbor not in g_score or tentative_g < g_score[neighbor]:
came_from[neighbor] = current
g_score[neighbor] = tentative_g
f_score = tentative_g + heuristic(neighbor, goal)
heapq.heappush(open_set, (f_score, neighbor))
return None # no path found
# 0 = safe ground, 1 = rock or hazard
terrain = [
[0, 0, 0, 1, 0],
[0, 1, 0, 1, 0],
[0, 1, 0, 0, 0],
[0, 0, 0, 1, 0],
[1, 1, 0, 0, 0],
]
path = a_star_path(terrain, (0, 0), (4, 4))
print("Rover path:", path)
A* is one of the oldest and most reliable pathfinding algorithms in computer science, and it is still genuinely useful today. The real Mars rovers combine this kind of logic with computer vision, so they can identify rocks and slopes from camera images in real time, then plan a route around them. It is a good reminder that AI in space does not always mean the newest, flashiest technique. Sometimes the best tool is a well understood algorithm applied to a genuinely hard environment.
Tracking Space Debris: Keeping the Sky Safe
There are currently over thirty thousand tracked objects larger than 10 centimeters orbiting Earth, and millions of smaller fragments too small to track individually. Objects in low Earth orbit travel at roughly 28,000 kilometers per hour, so even a fleck of paint hits with enough force to damage a satellite. This is a real and growing problem. Organizations like the ESA Space Debris Office, and commercial players like LeoLabs, now rely on automated systems to keep up with it, since no team of analysts could manually track this many objects in real time.
The core task is prediction. Given the current position and speed of two objects, will they come close enough to collide, and how soon? Doing this for one pair of objects is simple physics. Doing it continuously for tens of thousands of objects, and re-checking every time something moves, is a computational problem that benefits enormously from automation.
import numpy as np
def collision_risk(pos1, vel1, pos2, vel2, time_window=3600, threshold_km=5):
"""
Estimates whether two orbiting objects will pass within
a risky distance of each other within the given time window (seconds).
Positions in km, velocities in km/s.
"""
closest_distance = float('inf')
closest_time = 0
for t in range(0, time_window, 10):
future_pos1 = pos1 + vel1 * t
future_pos2 = pos2 + vel2 * t
distance = np.linalg.norm(future_pos1 - future_pos2)
if distance < closest_distance:
closest_distance = distance
closest_time = t
at_risk = closest_distance < threshold_km
return {
"at_risk": at_risk,
"closest_distance_km": round(closest_distance, 2),
"time_to_closest_approach_sec": closest_time
}
# Example: two objects on a potential collision course
pos1 = np.array([7000.0, 0.0, 0.0])
vel1 = np.array([0.0, 7.5, 0.0])
pos2 = np.array([7005.0, 0.0, 0.0])
vel2 = np.array([0.0, 7.4, 0.1])
result = collision_risk(pos1, vel1, pos2, vel2)
print(result)
Real collision avoidance systems are far more sophisticated than this, they account for orbital mechanics, atmospheric drag, and sensor uncertainty, but the underlying goal is the same. Flag the pairs of objects worth a closer look, so mission controllers do not have to manually check every possible combination of thirty thousand objects against each other.
Why This Matters Beyond the Code
None of these systems fly a spacecraft on their own, and none of them decide where to look for the next Earth like planet. Scientists still make those calls. What AI changes is how much ground a small team can cover.
A graduate student today can search more stars for exoplanets in an afternoon than an entire observatory could search in a year, twenty years ago. A rover can travel further in a single day because it does not have to stop and wait for instructions from a planet 14 light minutes away. A handful of engineers can monitor tens of thousands of objects in orbit, instead of a handful.
That is really what this series is about. AI does not replace human curiosity or judgment. It removes the bottleneck that used to sit between a good question and a good answer. In space exploration, where the questions are some of the biggest we have, that bottleneck used to be measured in years. Now, in many cases, it is measured in hours.
Every image captured by a satellite, every signal recorded by a telescope, and every kilometer traveled by a rover adds another piece to humanity’s understanding of the universe. AI isn’t replacing the explorers. It’s becoming one of their most powerful tools.
Next week, I will look at how the same idea plays out in a very different field: healthcare, where AI is helping doctors catch diseases earlier than ever before.
Comments
Loading comments…