Рубрика: AI

This week in AI: The generative AI boom drives demand for custom chips Kyle Wiggers Devin Coldewey 7 hours

Keeping up with an industry as fast-moving as AI is a tall order. So until an AI can do it for you, here’s a handy roundup of recent stories in the world of machine learning, along with notable research and experiments we didn’t cover on their own.

This week in AI, D-Matrix, an AI chip startup, raised $110 million to commercialize what it’s characterizing as a “first-of-its-kind” inference compute platform. D-Matrix claims that its tech enables inference — that is, running AI models — at a lower cost of ownership than GPU-based alternatives.

“D-Matrix is the company that will make generative AI commercially viable,” said Playground Global partner Sasha Ostojic, a D-Matrix backer.

Whether D-Matrix delivers on that promise is an open question. But the enthusiasm for it and startups like it — see NeuReality, Tenstorrent, etc. — shows growing awareness among the tech industry players of the severity of the AI hardware shortage. As generative AI adoption accelerates, the suppliers of the chips that run these models, like Nvidia, are struggling to keep pace with demand.

Recently, Microsoft warned shareholders of potential Azure AI service disruptions if it can’t get enough AI chips — specifically GPUs — for its datacenters. Nvidia’s best AI chips are reportedly sold out until 2024, thanks partly to sky-high demand from overseas tech giants including Baidu, ByteDance, Tencent and Alibaba.

It’s no wonder that Microsoft, Amazon and Meta, among others, are investing in developing in-house next-gen chips for AI inferencing. But for the companies without the resources to pursue that drastic course of action, hardware from startups like D-Matrix might be the next best thing.

In the most optimistic scenario, D-Matrix and its kin will act as an equalizing force, leveling the playing field for startups in the generative AI — and broader AI, for that matter — space. A recent analysis by AI research firm SemiAnalysis reveals how the AI industry’s reliance on GPUs is dividing the tech world into “GPU rich” and “GPU poor,” the former group being populated by incumbents like Google OpenAI and the latter group comprising mostly European startups and government-backed supercomputers like France’s Jules Verne.

Inequity plagues the AI industry, from the annotators who label the data used to train generative AI models to the harmful biases that often emerge in those trained models. Hardware threatens to become another example. That’s not to suggest all hopes are riding on startups like D-Matrix — new AI techniques and architectures could help address the imbalance, too. But cheaper, commercially available AI inferencing chips promise to be an important piece of the puzzle.

Here are some other AI stories of note from the past few days:

• Imbue raises $200M: Imbue, the AI research lab formerly known as Generally Intelligent, has raised $200 million in a Series B funding round that values the company at over $1 billion. Imbue launched out of stealth last October with an ambitious goal: to research the fundamentals of human intelligence that machines currently lack. The new tranche will be put toward the startup’s efforts to achieve that.
• eBay generates listings from photos: eBay is rolling out a new AI tool for marketplace sellers that can generate a product listing from a single photo. It’s potentially a major time saver. But as some users have discovered, eBay’s generative AI tools so far have tended to underwhelm in the quality department.
• Anthropic launches a paid plan: Anthropic, the AI startup co-founded by ex-OpenAI employees, has announced the launch of its first consumer-facing premium subscription plan, Claude Pro, for Claude 2 — Anthropic’s AI-powered, text-analyzing chatbot.
• OpenAI launches a dev conference: OpenAI will host a developer conference — its first ever — on November 6, the company announced this week. At the one-day OpenAI DevDay event, which will feature a keynote address and breakout sessions led by members of OpenAI’s technical staff, OpenAI said in a blog post that it’ll preview “new tools and exchange ideas” — but left the rest to the imagination.
• Zoom rebrands AI tools — and intros new ones: To stay competitive in the crowded market for videoconferencing, Zoom is updating and rebranding several of its AI-powered features, including the generative AI assistant formerly known as Zoom IQ.
• Are AI models doomed to hallucinate?: Large language models like OpenAI’s ChatGPT all suffer from the same problem: they make stuff up. But will that always be the case? We ask experts for their two cents.
• Prosecutors combat AI child exploitation: The attorneys general in all 50 U.S. states, plus four territories, signed onto a letter calling for Congress to take action against AI-enabled child sexual abuse material. Generative AI is generally benign in the child pornography department. But in the worst cases, as the attorneys general point out, it can be leveraged to facilitate abuse.
• Artisse generates photos of you: A new tool, Artisse, allows users to generate AI photos of themselves by first uploading a series of selfies. That’s not incredibly novel; other tools do this. But Artisee claims to improve on the current crop of AI photo apps by offering a broader range of both input and output capability and more realism in the resulting photos, even if set in fantastical realms.

More machine learnings

Image Credits: UZH / Leonard Bauersfeld

In first place, literally, we have this AI-driven high-speed drone, which managed to beat the human world champions at the sport, in which the pilots guide their drones at speeds of up to 100 km/h through a series of gates. An AI model was trained in a simulator, which “helped avoid destroying multiple drones in the early stages of learning,” and performed all its calculations in real time, achieving the best lap by half a second. Humans still respond better to changing conditions like light and course switcheroos, but it may only be a matter of time before the AI catches up to them there, too.

Machine learning models are advancing in other, unexpected modalities as well: Osmo, which aims to “give computers a sense of smell,” published a paper in Science showing that scent can in fact reliably be quantified and mapped. “RGB is a three-dimensional map of all colors…We view our discovery of the Principal Odor Map (POM) as the olfactory version of RGB.” The model successfully predicted the characteristics of scents it hadn’t encountered before, bearing out POM’s validity. The company’s first market looks to be streamlining fragrance synthesis. This paper actually made the rounds as a preprint last year but now it’s in Science, which means it actually counts.

The Principal Odor Map, or as I call it, Smellspace. Image Credits: Osmo

It would not be accurate to say that AI is also good at audition in this other study, but it is fitting that we have another sense in the mix. Biologists at Imperial College London recorded almost 36,000 hours of audio from more than 300 sites across Costa Rica so they could track wildlife there. It would have taken 20 years, or 20 grad students 1 year, to listen to it all, but machine learning models are great at pulling signal out of noise, so they analyzed it in two months. Turns out Costa Rican howlers don’t like it where there’s less than 80% tree cover, and are more sensitive to human presence than those in Mexico.

Microsoft’s AI for Good Research Lab has a couple projects along similar lines, which Juan Lavista Ferres gets into in this post. And here, in Spanish. Basically it’s the same problem of too much data and not enough time or people to look at it. With specially trained models, however, they can work through hundreds of thousands of motion-triggered photos, satellite images, and other data. By quantifying things like the extent and secondary effects of deforestation, projects like these provide solid empirical backing for conservation efforts and laws.

No roundup is complete without some new medical application, and indeed at Yale they have found that ultrasounds of the heart can be analyzed by a machine learning model to detect severe aortic stenosis, a form of heart disease. Making a diagnosis like this faster and easier can save lives, and even when it’s not 100% confident, it can tip a non-specialist care provider off that maybe a doctor should be consulted.

Last we have a bit of analysis from reporters at ChinaTalk, who put Baidu’s latest LLM, Ernie, through the wringer. It works primarily in Chinese, so it’s all second hand, but the gist is as you might expect from the country’s restrictive regulations around AI. “Spicy” topics like Taiwanese sovereignty are rejected, and it made “moral assertions and even policy proposals” that sometimes reflect the current regime, and at other times are a little odd. It loves Richard Nixon, for instance. But it does what some LLMs seem incapable of doing: just shutting up when it thinks it’s entering dangerous territory. Would that we all had such admirable discretion.

Image by Author

As a software developer, you’ll have likely heard the quote “Premature optimization is the root of all evil”—more than once—in your career. While optimization may not be super helpful (or absolutely necessary) for small projects, profiling is often helpful.

After you’ve finished coding a module, it’s a good practice to profile your code to measure how long each of the sections takes to execute. This can help identify code smells and guide optimizations to improve code quality. So always profile your code before optimizing!

To take the first steps, this guide will help you get started with profiling in Python—using the built-in timeit and cProfile modules. You’ll learn to use both the command-line interface and the equivalent callables inside Python scripts.

How To Profile Python Code Using timeit

The timeit module is part of the Python standard library and offers a few convenience functions that can be used to time short snippets of code.

Let's take a simple example of reversing a Python list. We’ll measure the execution times of obtaining a reversed copy of the list using:

• the reversed() function, and
• list slicing.

>>> nums=[6,9,2,3,7]  >>> list(reversed(nums))  [7, 3, 2, 9, 6]  >>> nums[::-1]  [7, 3, 2, 9, 6]

Running timeit at the Command Line

You can run timeit at the command line using the syntax:

$ python -m timeit -s 'setup-code' -n 'number' -r 'repeat' 'stmt'

You’re required to provide the statement stmt whose execution time is to be measured.

You can specify the setup code when needed—using the short option -s or the long option —setup. The setup code will be run only once.

The number of times to run the statement: short option -n or the long option —number is optional. And the number of times to repeat this cycle: short option -r or the long option —repeat is optional, too.

Let’s see the above in action for our example:

Here creating the list is the setup code and reversing the list is the statement to be timed:

$ python -m timeit -s 'nums=[6,9,2,3,7]' 'list(reversed(nums))'  500000 loops, best of 5: 695 nsec per loop

When you don’t specify values for repeat, the default value of 5 is used. And when you don’t specify number, the code is run as many times as needed so as to reach a total time of at least 0.2 seconds.

This example explicitly sets the number of times to execute the statement:

$ python -m timeit -s 'nums=[6,9,2,3,7]' -n 100Bu000 'list(reversed(nums))'  100000 loops, best of 5: 540 nsec per loop

The default value of repeat is 5, but we can set it to any suitable value:

$ python3 -m timeit -s 'nums=[6,9,2,3,7]' -r 3 'list(reversed(nums))'  500000 loops, best of 3: 663 nsec per loop

Let’s also time the list slicing approach:

$ python3 -m timeit -s 'nums=[6,9,2,3,7]' 'nums[::-1]'  1000000 loops, best of 5: 142 nsec per loop

The list slicing approach seems to be faster (all examples are in Python 3.10 on Ubuntu 22.04).

Running timeit in a Python Script

Here’s the equivalent of running timeit inside the Python script:

import timeit    setup = 'nums=[9,2,3,7,6]'  number = 100000  stmt1 = 'list(reversed(nums))'  stmt2 = 'nums[::-1]'    t1 =  timeit.timeit(setup=setup,stmt=stmt1,number=number)  t2 = timeit.timeit(setup=setup,stmt=stmt2,number=number)    print(f"Using reversed() fn.: {t1}")  print(f"Using list slicing: {t2}")

The timeit() callable returns the execution time of stmt for number of times. Notice that we can explicitly mention the number of times to run, or make number take the default value of 1000000.

Output >>  Using reversed() fn.: 0.08982690000000002  Using list slicing: 0.015550800000000004

This runs the statement—without repeating the timer function—for the specified number of times and returns the execution time. It is also quite common to use time.repeat() and take the minimum time as shown:

import timeit    setup = 'nums=[9,2,3,7,6]'  number = 100000  stmt1 = 'list(reversed(nums))'  stmt2 = 'nums[::-1]'    t1 =  min(timeit.repeat(setup=setup,stmt=stmt1,number=number))  t2 = min(timeit.repeat(setup=setup,stmt=stmt2,number=number))    print(f"Using reversed() fn.: {t1}")  print(f"Using list slicing: {t2}")

This will repeat the process of running the code number of times repeat number of times and returns the minimum execution time. Here we have 5 repetitions of 100000 times each.

Output >>  Using reversed() fn.: 0.055375300000000016  Using list slicing: 0.015101400000000043

How To Profile a Python Script Using cProfile

We have seen how timeit can be used to measure the execution times of short code snippets. However, in practice, it's more helpful to profile an entire Python script.

This will give us the execution times of all the functions and method calls—including built-in functions and methods. So we can get a better idea of the more expensive function calls and identify opportunities for optimization. For example: there might be an API call that's too slow. Or a function may have a loop that can be replaced by a more Pythonic comprehension expression.

Let’s learn how to profile Python scripts using the cProfile module (also part of the Python standard library).

Consider the following Python script:

# main.py  import time    def func(num):      for i in range(num):          print(i)    def another_func(num):      time.sleep(num)      print(f"Slept for {num} seconds")    def useful_func(nums, target):      if target in nums:          return nums.index(target)    if __name__ == "__main__":      func(1000)      another_func(20)      useful_func([2, 8, 12, 4], 12)

Here we have three functions:

• func() that loops through a range of numbers and prints them out.
• another func() that contains a call to the sleep() function.
• useful_func() that returns the index of a target number in list (if the target is present in the list).

The above-listed functions will be called each time you run the main.py script.

Running cProfile at the Command Line

Run cProfile at the command line using:

python3 -m file-name.py

Here we’ve named the file main.py:

python3 -m main.py

Running this should give you the following output:

  Output >>    0    ...    999    Slept for 20 seconds

And the following profile:

Here, ncalls refers to the number of calls to the function and percall refers to the time per function call. If the value of ncalls is greater than one, then percall is the average time across all calls.

The execution time of script is dominated by another_func that uses the built-in sleep function call (sleeps for 20 seconds). We see that print function calls are quite expensive too.

Using cProfile in the Python Script

While running cProfile at the command line works fine, you can also add the profiling functionality to the Python script. You can use cProfile coupled with the pstats module for profiling and accessing statistics.

As a best practice to handle resource setup and teardown better, use the with statement and create a profile object that’s used as a context manager:

# main.py  import pstats  import time  import cProfile    def func(num):      for i in range(num):          print(i)    def another_func(num):      time.sleep(num)      print(f"Slept for {num} seconds")    def useful_func(nums, target):      if target in nums:          return nums.index(target)      if __name__ == "__main__":      with cProfile.Profile() as profile:          func(1000)          another_func(20)          useful_func([2, 8, 12, 4], 12)      profile_result = pstats.Stats(profile)      profile_result.print_stats()

Let’s take a closer look at the output profile generated:

When you’re profiling a large script, it’ll be helpful to sort the results by execution time. To do so you can call sort_stats on the profile object and sort based on the execution time:

...  if __name__ == "__main__":      with cProfile.Profile() as profile:          func(1000)          another_func(20)          useful_func([2, 8, 12, 4], 12)      profile_result = pstats.Stats(profile)      profile_result.sort_stats(pstats.SortKey.TIME)      profile_result.print_stats()

When you now run the script, you should be able to see the results sorted by time:

Conclusion

I hope this guide helps you get started with profiling in Python. Always remember, optimizations should never come at the cost of readability. If you’re interested in learning about other profilers, including third-party Python packages, check out this article on Python profilers.
Bala Priya C is a developer and technical writer from India. She likes working at the intersection of math, programming, data science, and content creation. Her areas of interest and expertise include DevOps, data science, and natural language processing. She enjoys reading, writing, coding, and coffee! Currently, she's working on learning and sharing her knowledge with the developer community by authoring tutorials, how-to guides, opinion pieces, and more.

More On This Topic

• Pandas Profiling: One-Line Magical Code for EDA
• Top 18 Low-Code and No-Code Machine Learning Platforms
• Write Clean Python Code Using Pipes
• Extraction of Objects In Images and Videos Using 5 Lines of Code
• Real Time Image Segmentation Using 5 Lines of Code
• Optimizing Python Code Performance: A Deep Dive into Python Profilers

Image by Author

As the demand for programmers increases, the supply naturally will meet with more people entering the industry everyday. However, it is a competitive industry. In order to continuously improve yourself, skill-set and increase your salary — you need to prove that you are a proficient programmer. One way you can do this is by learning the things that people don’t typically know.

A lot of people break into the programming industry with the assumption that you do not need to know the Math behind it. Although this is somewhat true, being able to understand the logical mathematical concept behind programming will make you a more proficient programmer.

How is that? By understanding what you are doing and what is happening. That’s how.

So let’s jump right into it. What are the top 10 math concepts for programmers?

Boolean Algebra

Boolean algebra stems off algebra. I guess that was obvious. If you are a programmer or on your quest to become one, you probably already know what Boolean is. If not, I'll quickly define it.

Boolean is a data type/binary variable that has one of the two possible values, for example 0 (false) or 1 (true). The boolean data type is backed by boolean algebra, in which the variable's values are known as the truth values, true and false. When working with boolean algebra, there are three operators that you can use:

• Conjunction or AND operation
• Disjunction or OR operation
• Negation or Not operation

These can be visually represented as venn diagrams, to give you a better understanding of the output. Boolean algebra is made up of 6 laws:

• Commutative law
• Associative law
• Distributive law
• AND law
• OR law
• Inversion law

Numeral Systems

Computers understand numbers, and this is why they need a numeral system. A numeral system is known as a writing system used to express numbers. For example, you have these four most common number system types:

1. Decimal number system (Base- 10)
2. Binary number system (Base- 2)
3. Octal number system (Base-8)
4. Hexadecimal number system (Base- 16)

Computers work off a Base- 2 numeral system, where the possible digits are 0 and 1. Base64 is also used to encode binary data in a string format.

Floating Point

More on learning about numbers, we have floating point. A floating point is a variable data type which represents real numbers as an approximation. A floating-point number is a number in which the position of the decimal point can move around or "float" instead of being in a fixed position. This allows developers to make a trade-off between range and precision.

But why an approximation? Computers only have a limited amount of space, either 32 bits (single precision) or 64 bits (double precision). 64 bit is the default for programming languages such as Python and JavaScript. An example of floating-point numbers are 1.29, 87.565, and 9038724.2. It can either be a positive or negative whole number with a decimal point.

Logarithms

Also known as log is a mathematical concept that uses the inverse of exponentials to answer the question. So why is logarithms important to programmers> Because it simplifies complex mathematical calculations. For example, 1000 = 10^4 can also be written as 4 = log101000.

The base number is a mathematical object that needs to be multiplied by itself. The exponent is a number that identifies how many times a base number needs to be multiplied by itself. Therefore, a logarithm is an exponent which indicates to what power a base must be raised to produce a given number.

When log uses Base- 2 it is a binary logarithm, and if it’s Base- 10 it is a common logarithm.

Set Theory

A set is an unordered unique collection of values, which do not need to have any relation to one another. They can only contain unique items, and cannot contain the same item twice or more.

For example excel files or a database contain tables which have a set of unique rows. This is a type of discrete math as these structures can have a finite number of elements. The aim of set theory is to understand the collections of values, and the relations between one another. This is typically used for data analysts, SQL experts and data scientists.

You can do this by using:

• Inner join or intersection — Returns a set containing elements that are present in both sets
• Outer join or union — Returns elements from both sets
• Union all – Same as the outer join operator, but it will contain all duplicates.
• Except or Minus – A Minus B is a set containing elements from the set A that are not elements of the set B

Combinatorics

Combinatorics is the art of counting things in order to obtain results, and understand certain properties of finite structures through patterns. Programming is all about solving problems, and combinatorics is the way we can arrange objects to study these finite discrete structures.

The Combinatorics formula is a combination of Permutation and Combination.

• Permutation is the act of arranging a set into some order or sequence
• Combination is the selection of values of the set where the order is not taken into consideration.

Graph Theory

As you already know, a graph is a visual representation of a set of values and these values can be connected. When it comes to data, these values are connected due to variables — which in graph theory are known as links.

Graph Theory is the study of graphs concerning the relationship among edges and vertices of connected sets of points. This allows us to create a pairwise relationship between objects using the vertices, also known as nodes that are connected by the edges, known as the lines. A graph is represented as a pair G(V, E), where V represents the finite set vertices and E represents the finite set edges.

Complexity Theory

Complexity theory is the study of the amount of time and memory it takes for an algorithm to run as a function of the input size. There are two types of complexities:

• Space complexity — the amount of memory an algorithm needs to run.
• Time complexity — the amount of time an algorithm needs to run.

More people are concerned about time complexity as we can reuse the memory of an algorithm. When it comes to time complexity, the best way to measure it is by considering the number of operations the algorithm performs. Algorithms are built using if-statements and loops, therefore to reduce time spent you want to use code that has as few if-statements and loops as possible.

Complexity theory for algorithms uses the big-o notation to help describe and provide a better understanding of the limiting behavior of an algorithm. It is used to classify algorithms by how they respond to changes in input size.

Statistics

Ahhh statistics. If you’re looking to get into artificial intelligence, you need to know about statistics. AI and machine learning are nice names used for statistics. Statistical programming is used to solve data-heavy problems, such as ChatGPT. ChatGPT’s response is all based on the probability of matching the prompt provided by the user.

You will need to learn more than mean, median and mode when it comes to statistical programming. You will need to learn about bias, covariance, and bayes theorem. As a programmer, you will be set tasks and realize you will be asking is this a linear regression problem or a logistic regression problem. Understanding the difference between the two will help you identify what type of task you have at hand.

Linear Algebra

You may have looked at linear algebra in school — or you may have not. Linear algebra is very important and is widely used in computer graphics and deep learning. In order to grasp linear algebra, you will need to understand these three words:

• Scalar — a single numerical value
• Vector — a list of numbers or 1 dimensional array
• Matrix — a grid or 2 dimensional array

Vectors can represent points and the direction in a 3D space, whereas matrices can represent transformations that happen to these vectors.

Wrapping it up

This article provides you with a quick overview of the top 10 math concepts that will improve your programming career. Learning the intricacies will not only make your day-to-day tasks smoother and easier to understand, but it can be showcased to your employer on your potential.

If you are looking for a FREE book to help you, check out: Mathematics for Machine Learning: The Free eBook
Nisha Arya is a Data Scientist, Freelance Technical Writer and Community Manager at KDnuggets. She is particularly interested in providing Data Science career advice or tutorials and theory based knowledge around Data Science. She also wishes to explore the different ways Artificial Intelligence is/can benefit the longevity of human life. A keen learner, seeking to broaden her tech knowledge and writing skills, whilst helping guide others.

More On This Topic

• How To Overcome The Fear of Math and Learn Math For Data Science
• Best Python Books for Beginners and Advanced Programmers
• Will DeepMind’s AlphaCode Replace Programmers?
• 5 Concepts You Should Know About Gradient Descent and Cost Function
• The 8 Basic Statistics Concepts for Data Science
• Advanced Statistical Concepts in Data Science

When every interview of Sam Altman is bound to throw a few pearls of wisdom, a recent podcast made Altman blatantly talk about an underlying truth of Silicon Valley. “I hate to say this because it sounds so arrogant but, before OpenAI, what was the last really great scientific breakthrough that came out of a Silicon Valley company?” asked Altman in a recent interview with Nicolai Tangen, CEO of Norges Bank Investment Management. Terming it an innovation decline in Silicon Valley, what transformation has the most sought-after tech hub in the world undergone?

Chasing Money

In the race to bag bigger funding, companies have been prioritising quicker returns. In the process, an innovation decline is bound to happen. Altman quipped that though he may not completely understand why this has happened, he believes that it has gotten easy to make a valuable company, that people started getting impatient on timelines and returns. “A lot of the capital went into things that could fairly reliably multiply money in a short period of time,” he said. Using existing technology such as the internet and mobile phones to revolutionise industries was compelling enough to attract talent to build such companies.

A discussion on Hacker News emphasises the dynamics of venture capital in the startup world. With VC firms seeking high returns with minimal risks, founders are often advised to focus on B2B markets over consumer markets. Furthermore, for more than a decade, the focus has been on building SaaS businesses, and the incentive has been on doing something simple that guarantees returns, rather than on thinking big to tackle challenging things.

Rise of Dragon and Falcon

What was believed to be the hot centre for tech innovation in the world, is now slowly changing owing to the global players. The rise of China’s prowess in the technology world has pushed the country as a worthy competitor to the US. Over the past twenty years, China has transformed from being a ‘technological backwater to an innovation powerhouse.’ Despite tight government control on markets, the country is now competing with the US on the latest emerging tech, including AI and quantum computing.

Looking at the latest developments across the globe, countries such as UAE, where research institutes have government funding, are building LLMs such as Falcon, which is proving to be a close competitor to GPT-4. Further implying that the US is no more the concentric region for springing forth competing tech.

Fading Sparkle

Silicon Valley’s innovation boom in the 1970s and 1980s was fueled by government funding and the establishment of major VC firms Kleiner Perkins and Sequoia Capital in 1972. The IT revolution during the same period further pushed the Silicon Valley status. Tech giants such as Apple, Microsoft, Atari, Oracle, Cisco, and others witnessed a rise in the same period. Furthermore, Apple’s 1981 IPO generated $1.3 billion solidified Silicon Valley’s status as the global hub for VC companies. However, the shine is slowly fading. Owing to a number of reasons, the last one being the pandemic, a huge shift in base is happening.

With inflation, rising costs of living with exorbitant housing situations, have proven the place to be livable by only those with hefty salaries. Wealth inequality in Silicon Valley is more pronounced than that across the country.

Furthermore, other cities across the US are emerging as new startup hot-beds, inviting VCs to aggressively fund in these regions. Company fundings in Miami quadrupled in the past three years with a total of $5.39 billion in 2022 alone. New York is witnessing an increase in tech talent and the ones most likely to shift from the West Coast are those who are five to ten years into their career.

Source: Washington Post

While Altman might have brought focus on the Silicon Valley innovation decline, some were quick to criticise him to consider OpenAI as the only innovator. The trivialisation attitude of the founder belittled the work of those who work on low-level stuff. “I think there is a point here that user-facing innovation stagnated and OpenAI helped break that, but it’s wild to me that there is no acknowledgement at all of the giants whose shoulders they stand on,” said a user on Hacker News.

The post Are Innovators Moving Away From Silicon Valley? appeared first on Analytics India Magazine.

A paradigm shift in the way media covers AI has been witnessed since OpenAI unfolded the curtains on ChatGPT. Scrolling on mobile, AI-related news pop-ups more often these days compared to a year ago. While some journalism houses talk about AI as an all-knowing oracle, very few focus their attention on the potential misuse of the technology brewing in Silicon Valley.

The one-sided coverage has a silver lining as AI is not just being described as bogus as it was half a decade ago. In an AIM podcast, emphasizing the need for media covering technology, Arvind Balasundaram of Regeneron pointed out that none of us got schooled about AI in classrooms.

While some are framing AI debates according to alarmist visions of the distant future, MIT Technology Review, Analytics India Magazine, WIRED and a few critical voices investigate other angles that are typically left out of business reporting. From economic framings to inequalities and injustices caused by AI, a new array of subjects has become a part of the mainstream media.

J. Scott Brennen, the lead author of a report on AI coverage, said the shift in media portrayal of AI occurs against a backdrop of economic disruption in the industry, with a downfall in specialized reporting in science and technology. He warns that while mainstream media remains a key space for public discussion, it often amplifies the self-serving claims of the tech industry without acknowledging the AI’s consequences. This type of coverage tends to underplay the role of public action in addressing the societal impact of technologies like AI.

AI’s TIME is here

Computer scientists and their research institutions are overwhelmingly present in AI coverage; a recent example is the first-of-its-kind TIME AI list. While legacy publications are acknowledging the community’s growing influence and trying to cover every nitty-gritty of it, the others are busy becoming the subject of technology. AI-generated virtual anchors have debuted in the Indian mediascape.

The growing tribe of robot anchors has received mixed reviews; from ‘emotionless’ to ‘path breaking’. Dressed in a maroon and gold sari, is Lisa, Odisha TV’s first AI newscaster. The lifelike anchor’s job is to deliver news bulletins on digital platforms, read horoscopes and provide weather and sports updates. The channel’s head, Jagi Mangat Panda explained that the objective of using an anchor powered by artificial intelligence was to let it handle repetitive work and free up staff to “focus on doing more creative work to bring better quality news.”

While the majority of newsrooms have started adopting the technology in the recent past several media houses took a step forward years ago. Bloomberg was an early adopter of Cyborg, a program that dissects financial reports and instantly writes news stories with all relevant facts and figures. The Washington Post made headlines when it started using Heliograf, a homegrown AI, to cover the 2016 Rio Olympic Games and congressional elections.

News Wire AP further exemplified the advantages of AI, increasing its quarterly article production on company earnings reports from 300 to 3,700. Lisa Gibbs, Director of News Partnerships and AI News Lead at AP highlighted that AI roughly generates 40,000 stories annually, though this is only a fraction of the agency’s total output. Nevertheless, the benefits of technology in newsrooms are manifold.

Assisting Journalists

Like other AI technologies, the adoption of virtual newscasters has also triggered fears of job losses, despite production companies’ assurances that robot anchors will never replace humans. Regardless of the debate, the use of AI in newsrooms looks likely to only grow. A survey published in May by the World Association of News Publishers found that 49% of all newsrooms globally were using AI tools like ChatGPT.

TIME noted, ‘What is unique about AI is also what is most feared and celebrated—its ability to match some of our skills, and then to go further, accomplishing what humans cannot’, in the pieces explaining the need for the AI 100 list.

While we have an instance of the story by the New York Times claiming Bing’s chatbot wanted to “be alive”; the media should be looking away from the dystopian point of view. Moving away to a much sober coverage should be the way forward according to Burrell of Data & Society, who thinks we’re still in the hype phase of the cycle on generative AI chatbots. Some recommendations as per reports suggest ways for reporters to cover the subject better.

Fear-mongering about AI replacing journalists is not a revelation. Dispelling the notion of AI replacing journalists, Wharton marketing professor Pinar Yildirim points to research indicating that media consumption is not purely rational. People seek news that aligns with their beliefs and worldviews, emphasizing the importance of human perspectives and storytelling in journalism. AI can augment, but not entirely replace, the essence of human-driven news. Yildirim said. “They want to hear news which appeals to their belief system — their version of the world.”

While legacy publications are busy rehashing the news available online, catching up with technicalities and misinformation, AIM entered the picture over a decade ago as a platform for journalists to thrive. From working closely with the developers’ ecosystem, an AI Forum for brewing discussion, and in-house AI powered tools, the company has created an environment for covering AI to the best of its abilities

The post When Journalists Write About AI appeared first on Analytics India Magazine.

Image by Author Motivation

PyTorch is the most widely used Python-based Deep Learning framework. It provides tremendous support for all machine learning architectures and data pipelines. In this article, we go through all the framework basics to get you started with implementing your algorithms.

All machine learning implementations have 4 major steps:

• Data Handling
• Model Architecture
• Training Loop
• Evaluation

We go through all these steps while implementing our own MNIST image classification model in PyTorch. This will familiarize you with the general flow of a machine-learning project.

Imports

import torch  import torch.nn as nn  import torch.optim as  optim    from torch.utils.data import DataLoader    # Using MNIST dataset provided by PyTorch  from torchvision.datasets.mnist import MNIST  import torchvision.transforms as transforms    # Import Model implemented in a different file  from model import Classifier    import matplotlib.pyplot as plt

torch.nn module provides support for neural network architectures and has built-in implementations for popular layers such as Dense Layers, Convolutional Neural Networks, and many more.

torch.optim provides implementations for optimizers such as Stochastic Gradient Descent and Adam.

Other utility modules are available for data handling support and transformations. We will go through each in more detail later.

Declare Hyperparameters

Each hyperparameter will be explained further where appropriate. However, it is a best practice to declare them at the top of our file for ease of change and understanding.

INPUT_SIZE = 784	# Flattened 28x28 images  NUM_CLASSES = 10	# 0-9 hand-written digits.  BATCH_SIZE = 128	# Using Mini-Batches for Training  LEARNING_RATE = 0.01	# Opitimizer Step  NUM_EPOCHS = 5  	# Total Training Epochs

Data Loading and Transforms

data_transforms = transforms.Compose([      	transforms.ToTensor(),      	transforms.Lambda(lambda x: torch.flatten(x))  ])    train_dataset = MNIST(root=".data/", train=True, download=True, transform=data_transforms)      test_dataset = MNIST(root=".data/", train=False, download=True, transform=data_transforms)

MNIST is a popular image classification dataset, provided by default in PyTorch. It consists of grayscale images of 10 hand-written digits from 0 to 9. Each image is of size 28 pixels by 28 pixels, and the dataset contains 60000 training and 10000 testing images.

We load the training and testing dataset separately, denoted by the train argument in the MNIST initialization function. The root argument declares the directory in which the dataset is to be downloaded.

However, we also pass an additional transform argument. For PyTorch, all inputs and outputs are supposed to be in Torch.Tensor format. This is equivalent to a numpy.ndarray in numpy. This tensor format provides additional support for data manipulation. However, the MNIST data we load from is in the PIL.Image format. We need to transform the images into PyTorch-compatible tensors. Accordingly, we pass the following transforms:

data_transforms = transforms.Compose([      	transforms.ToTensor(),      	transforms.Lambda(lambda x: torch.flatten(x))  ])

The ToTensor() transform converts images to tensor format. Next, we pass an additional Lambda transform. The Lambda function allows us to implement custom transforms. Here we declare a function to flatten the input. The images are of size 28×28, but, we flatten them i.e. convert them to a single-dimensional array of size 28×28 or 784. This will be important later when we implement our model.

The Compose function sequentially combines all the transforms. Firstly, the data is converted to tensor format and then flattened to a one-dimensional array.

Dividing our Data into Batches

For computational and training purposes, we can not pass the complete dataset into the model at once. We need to divide our dataset into mini-batches that will be fed to the model in sequential order. This allows faster training and adds randomness to our dataset, which can assist in stable training.

PyTorch provides built-in support for batching our data. The DataLoader class from torch. utils module can create batches of data, given a torch dataset module. As above, we already have the dataset loaded.

train_dataloader = DataLoader(train_dataset, batch_size=BATCH_SIZE, shuffle=True)  test_dataloader = DataLoader(test_dataset, batch_size=BATCH_SIZE, shuffle=False)

We pass the dataset to our dataloader, and our batch_size hyperparameter as initialization arguments. This creates an iterable data loader, so we can easily iterate over each batch using a simple for loop.

Our initial image was of size (784, ) with a single associated label. The batching then combines different images and labels in a batch. For example, if we have a batch size of 64, the input size in a batch will become (64, 784) and we will have 64 associated labels for each batch.

We also shuffle the training batch, which changes the images within a batch for each epoch. It allows for stable training and faster convergence of our model parameters.

Defining our Classification Model

We use a simple implementation consisting of 3 hidden layers. Although simple, this can give you a general understanding of combining different layers for more complex implementations.

As described above, we have an input tensor of size (784, ) and 10 different output classes, one for each digit from 0-9.

** For model implementation, we can ignore the batch dimension.

import torch  import torch.nn as nn      class Classifier(nn.Module):  	def __init__(          	self,          	input_size:int,          	num_classes:int      	) -> None:      	super().__init__()      	self.input_layer = nn.Linear(input_size, 512)      	self.hidden_1 = nn.Linear(512, 256)      	self.hidden_2 = nn.Linear(256, 128)      	self.output_layer = nn.Linear(128, num_classes)        	self.activation = nn.ReLU()     	   	def forward(self, x):      	# Pass Input Sequentially through each dense layer and activation      	x = self.activation(self.input_layer(x))      	x = self.activation(self.hidden_1(x))      	x = self.activation(self.hidden_2(x))      	return self.output_layer(x)

Firstly, the model must inherit from the torch.nn.Module class. This provides basic functionality for neural network architectures. We then must implement two methods, __init__ and forward.

In the __init__ method, we declare all layers the model will use. We use Linear (also called Dense) layers provided by PyTorch. The first layer maps the input to 512 neurons. We can pass input_size as a model parameter, so we can later use it for input of different sizes as well. The second layer maps the 512 neurons to 256. The third hidden layer maps the 256 neurons from the previous layer to 128. The final layer then finally reduces to the output size. Our output size will be a tensor of size (10, ) because we are predicting ten different numbers.

Image by Author

Moreover, we initialize a ReLU activation layer for non-linearity in our model.

The forward function receives images and we provide code for processing the input. We use the layers declared and sequentially pass our input through each layer, with an intermediate ReLU activation layer.

In our main code, we can then initialize the model providing it with the input and output size for our dataset.

model = Classifier(input_size=784, num_classes=10)  model.to(DEVICE)

Once initialized, we change the model device (which can be either CUDA GPU or CPU). We checked for our device when we initialized the hyperparameters. Now, we have to manually change the device for our tensors and model layers.

Training Loop

Firstly, we must declare our loss function and optimizer that will be used to optimize our model parameters.

criterion = nn.CrossEntropyLoss()  optimizer = optim.Adam(model.parameters(), lr=LEARNING_RATE)

Firstly, we must declare our loss function and optimizer that will be used to optimize our model parameters.

We use the Cross-Entropy Loss that is primarily used for multi-label classification models. It first applies softmax to the predictions and calculates the given target labels and predicted values.

Adam optimizer is the most-used optimizer function that allows stable gradient descent toward convergence. It is the default optimizer choice nowadays and provides satisfactory results. We pass our model parameters as an argument that denotes the weights that will be optimized.

For our training loop, we build step-by-step and fill in missing portions as we gain an understanding.

As a starting point, we iterate over the complete dataset multiple times (called epoch), and optimize our model each time. However, we have divided our data into batches. Then, for every epoch, we must iterate over each batch as well. The code for this will look as below:

for epoch in range(NUM_EPOCHS):      	for batch in iter(train_dataloader):            # Train the Model for each batch.  

Now, we can train the model given a single input batch. Our batch consists of images and labels. Firstly, we must separate each of these. Our model only requires images as input to make predictions. We then compare the predictions with the true labels, to estimate our model’s performance.

for epoch in range(NUM_EPOCHS):      	for batch in iter(train_dataloader):          	images, labels = batch # Separate inputs and labels          	# Convert Tensor Hardware Devices to either GPU or CPU          	images = images.to(DEVICE)          	labels = labels.to(DEVICE)         	           	# Calls the model.forward() function to generate predictions           	predictions = model(images)

We pass the batch of images directly to the model that will be processed by the forward function defined within the model. Once we have our predictions, we can optimize our model weights.

The optimization code looks as follows:

# Calculate Cross Entropy Loss  loss = criterion(predictions, labels)  # Clears gradient values from previous batch  optimizer.zero_grad()  # Computes backprop gradient based on the loss  loss.backward()  # Optimizes the model weights  optimizer.step()

Using the above code, we can compute all the backpropagation gradients and optimize the model weights using the Adam optimizer. All the above codes combined can train our model toward convergence.

Complete training loop looks as follows:

for epoch in range(NUM_EPOCHS):      	total_epoch_loss = 0      	steps = 0      	for batch in iter(train_dataloader):          	images, labels = batch # Separate inputs and labels          	# Convert Tensor Hardware Devices to either GPU or CPU          	images = images.to(DEVICE)          	labels = labels.to(DEVICE)         	           	# Calls the model.forward() function to generate predictions       	           	predictions = model(images)         	           	# Calculate Cross Entropy Loss          	loss = criterion(predictions, labels)          	# Clears gradient values from previous batch          	optimizer.zero_grad()          	# Computes backprop gradient based on the loss          	loss.backward()          	# Optimizes the model weights          	optimizer.step()         	           	steps += 1          	total_epoch_loss += loss.item()         	       	print(f'Epoch: {epoch + 1} / {NUM_EPOCHS}: Average Loss: {total_epoch_loss / steps}')

The loss gradually decreases and reaches close to 0. Then, we can evaluate the model on the test dataset we declared initially.

Evaluating our Model Performace

for batch in iter(test_dataloader):      	images, labels = batch      	images = images.to(DEVICE)      	labels = labels.to(DEVICE)     	       	predictions = model(images)     	       	# Taking the predicted label with highest probability      	predictions = torch.argmax(predictions, dim=1)     	       	correct_predictions += (predictions == labels).sum().item()      	total_predictions += labels.shape[0]        print(f"nTEST ACCURACY: {((correct_predictions / total_predictions) * 100):.2f}")

Similar to the training loop, we iterate over each batch in the test dataset for evaluation. We generate predictions for the inputs. However, for evaluation, we only need the label with the highest probability. The argmax function provides this functionality to obtain the index of the value with the highest value in our predictions array.

For the accuracy score, we can then compare if the predicted label matches the true target label. We then compute the accuracy of the number of correct labels divided by the total predicted labels.

Results

I only trained the model for five epochs and achieved a test accuracy of over 96 percent, as compared to 10 percent accuracy before training. The image below shows the model predictions after training five epochs.

There you have it. You have now implemented a model from scratch that can differentiate hand-written digits just from image pixel values.

This in no way is a comprehensive guide to PyTorch but it does provide you with a general understanding of structure and data flow in a machine learning project. This is nonetheless sufficient knowledge to get you started with implementing state-of-the-art architectures in deep learning.

Complete Code

The complete code is as follows:

model.py:

import torch  import torch.nn as nn      class Classifier(nn.Module):  	def __init__(          	self,          	input_size:int,          	num_classes:int      	) -> None:      	super().__init__()      	self.input_layer = nn.Linear(input_size, 512)      	self.hidden_1 = nn.Linear(512, 256)      	self.hidden_2 = nn.Linear(256, 128)      	self.output_layer = nn.Linear(128, num_classes)        	self.activation = nn.ReLU()     	   	def forward(self, x):      	# Pass Input Sequentially through each dense layer and activation      	x = self.activation(self.input_layer(x))      	x = self.activation(self.hidden_1(x))      	x = self.activation(self.hidden_2(x))      	return self.output_layer(x)

main.py

import torch  import torch.nn as nn  import torch.optim as  optim    from torch.utils.data import DataLoader    # Using MNIST dataset provided by PyTorch  from torchvision.datasets.mnist import MNIST  import torchvision.transforms as transforms    # Import Model implemented in a different file  from model import Classifier    import matplotlib.pyplot as plt    if __name__ == "__main__":        	INPUT_SIZE = 784	# Flattened 28x28 images  	NUM_CLASSES = 10	# 0-9 hand-written digits.  	BATCH_SIZE = 128	# Using Mini-Batches for Training  	LEARNING_RATE = 0.01	# Opitimizer Step  	NUM_EPOCHS = 5  	# Total Training Epochs    	DEVICE = 'cuda' if torch.cuda.is_available() else 'cpu'        	# Will be used to convert Images to PyTorch Tensors  	data_transforms = transforms.Compose([      	transforms.ToTensor(),      	transforms.Lambda(lambda x: torch.flatten(x))  	])              	train_dataset = MNIST(root=".data/", train=True, download=True, transform=data_transforms)  	test_dataset = MNIST(root=".data/", train=False, download=True, transform=data_transforms)            	train_dataloader = DataLoader(train_dataset, batch_size=BATCH_SIZE, shuffle=True)  	test_dataloader = DataLoader(test_dataset, batch_size=BATCH_SIZE, shuffle=False)              	model = Classifier(input_size=784, num_classes=10)  	model.to(DEVICE)        	criterion = nn.CrossEntropyLoss()  	optimizer = optim.Adam(model.parameters(), lr=LEARNING_RATE)        	for epoch in range(NUM_EPOCHS):      	total_epoch_loss = 0      	steps = 0      	for batch in iter(train_dataloader):          	images, labels = batch # Separate inputs and labels          	# Convert Tensor Hardware Devices to either GPU or CPU          	images = images.to(DEVICE)          	labels = labels.to(DEVICE)         	           	# Calls the model.forward() function to generate predictions       	           	predictions = model(images)         	           	# Calculate Cross Entropy Loss          	loss = criterion(predictions, labels)          	# Clears gradient values from previous batch          	optimizer.zero_grad()          	# Computes backprop gradient based on the loss          	loss.backward()          	# Optimizes the model weights          	optimizer.step()         	           	steps += 1          	total_epoch_loss += loss.item()         	       	print(f'Epoch: {epoch + 1} / {NUM_EPOCHS}: Average Loss: {total_epoch_loss / steps}')  	# Save Trained Model  	torch.save(model.state_dict(), 'trained_model.pth')        	model.eval()  	correct_predictions = 0  	total_predictions = 0  	for batch in iter(test_dataloader):      	images, labels = batch      	images = images.to(DEVICE)      	labels = labels.to(DEVICE)     	       	predictions = model(images)     	       	# Taking the predicted label with highest probability      	predictions = torch.argmax(predictions, dim=1)     	       	correct_predictions += (predictions == labels).sum().item()      	total_predictions += labels.shape[0]        	print(f"nTEST ACCURACY: {((correct_predictions / total_predictions) * 100):.2f}")                    	# --  Code For Plotting Results  -- #        	batch = next(iter(test_dataloader))  	images, labels = batch        	fig, ax = plt.subplots(nrows=1, ncols=4, figsize=(16,8))  	for i in range(4):      	image = images[i]      	prediction = torch.softmax(model(image), dim=0)      	prediction = torch.argmax(prediction, dim=0)      	# print(type(prediction), type(prediction.item()))      	ax[i].imshow(image.view(28,28))      	ax[i].set_title(f'Prediction: {prediction.item()}')  	plt.show()

Muhammad Arham is a Deep Learning Engineer working in Computer Vision and Natural Language Processing. He has worked on the deployment and optimizations of several generative AI applications that reached the global top charts at Vyro.AI. He is interested in building and optimizing machine learning models for intelligent systems and believes in continual improvement.

More On This Topic

• A Bug That Can Make You a Data Science Hero
• Zero to RAPIDS in Minutes with NVIDIA GPUs + Saturn Cloud
• Breaking the Data Barrier: How Zero-Shot, One-Shot, and Few-Shot Learning…
• Zero-shot Learning, Explained
• 4 Machine Learning Concepts I Wish I Knew When I Built My First Model
• How to Create Stunning Web Apps for your Data Science Projects

Undoubtedly, NVIDIA has been at the forefront of AI in terms of providing hardware and even software capabilities. On the other hand, it seems like it has been relatively quiet on the other technological front—quantum computing. In this field, IBM has been taking the shots and providing everyone with the capabilities, while also giving others a run for their money.

According to the recent International Data Corporation (IDC) report IBM is the leader in MarketSpace on quantum computing systems, followed by Rigetti Computing and Quantinuum in the major players segment.

Interestingly, NVIDIA is nowhere to be found in the report.

NVIDIA chief Jensen Huang seemed to care less, and told AIM that it would take at least two more decades for quantum computing to be actually useful, or even exist. “It needs to be classical plus quantum,” said Huang. The algorithms we create today are not going to run well on quantum computers as they need to be made on quantum computers. “Classical computers will not go away,” and would be a part of the future of quantum computing.

How to be the NVIDIA of quantum

“We support every single quantum computing centre in quantum computing,” expressed Huang. NVIDIA believes that it is making big strides in quantum computing. AWS, Oracle, Deloitte, and few others have been leveraging cuQuantum on their servers. The company has been accelerating research in quantum computing through cuQuantum, its CUDA-like SDK built for accelerating quantum computing research which is using NVIDIA Tensor Core GPUs for speeding up quantum circuit simulations.

But when it comes to IBM, the company has been following a similar approach for the last five decades and has been making big claims when it comes to quantum computing. But the claims are slowly taking shape for the company. IBM says that Boeing, Samsung, Sony, Vodafone, Capgemini, JP Morgan Chase & Co, MIT are members of the IBM Quantum real applications.

In 2022, Arvind Krishna, CEO of IBM said that organisations would be able to deploy quantum computers “in the 2023 to 2025 time frame” and a 4,000 qubit system would be available by 2025. This was possibly a hint at the company’s plan to combine 3 Kookaburra processors, totaling into 4,158 qubits, according to the roadmap.

However, NVIDIA is married to the idea of classical computing, as that is what has been earning the company the most bucks at the moment. It has announced many plans and partnerships in recent months like the DGX Quantum – a system which couples GPUs, which is classical, and quantum computing.

NVIDIA’s approach is quite different from IBM’s quantum only approach.

What is IBM doing right?

NVIDIA has been in the AI game for the last 30 years, and that is how long it took for the company to be the leader. At the NTU speech Huang said that in spite of the several failures, the company’s approach made it to where it is today. It made its first GPU in 1999 and then with the release of CUDA in 2007, the company made parallel processing for AI computing possible for everyone in the world.

Similarly, IBM started its quantum computing journey in 1970 and over the last five decades, the company has continuously invested in quantum research, focusing on the research and design of a full-stack superconducting quantum computer. However, according to IBM’s review on the quantum computing report, the company’s focus is not just on being the best, but also enabling an entire ecosystem of quantum and craft a path to quantum advantage.

It is clearly visible in IBM’s approach towards quantum computing. In 2016, the company took the first step in advancing the quantum computing industry by releasing its 5-qubit system to the IBM Cloud. This was the first time a quantum computing hardware was made available for research and public experimentation, along with the software release of Qiskit, an open source and hardware-agnostic SDK for running on quantum computers.

Forging ahead, in 2017, IBM decided to release a client-facing IBM Quantum Network for providing quantum computing-as-a-service (QCaaS) for the companies, governments, academic institutions, and startups as well for full experimentation with the company’s quantum hardware.

NVIDIA’s optimistic approach towards AI, and a little pessimistic one towards quantum computing is understandable. NVIDIA is a careful trotter in quantum, and is all about discipline. Taking the example of CUDA, NVIDIA made AI accessible to all, and now its wants replicate its success in quantum computing.

“The foresight was accelerated computing. The foresight was making this architecture exactly the same for everybody. Having the discipline of staying true to that platform for generation after generation, believing that eventually our install base would be so large that not only would we have reach, but applications would therefore be enabled by us. New applications that weren’t possible before would discover us,” said Huang, in an interview with CNBC.

Now, all NVIDIA needs to do is move forward with the same approach, while IBM leads the way, breaking boundaries making powerful quantum computers – the same way it made the first computer.

The post Is IBM the NVIDIA of Quantum Computing? appeared first on Analytics India Magazine.

As ISRO basks in the massive success of Chandrayaan-3 and Aditya-L1, the spotlight also turns to 140 homegrown space tech startups that have quietly emerged as key players. In 2022, India marked its space milestones, including Skyroot’s inaugural private rocket launch and multiple satellite deployments, garnering global attention.

These achievements are bolstered by the government’s trust and support for domestic private space tech firms, through funding, technology access, and infrastructure assistance. In a significant move, the GST Council introduced a 0% GST regime for space tech startups in July, fostering growth in this burgeoning sector.

India’s space tech landscape saw remarkable growth, with approximately $205 million raised in funding across 30+ deals between 2014 and July 2023. Moreover, a December 2022 study by IBEF revealed that India accounted for 2.6% of the global space economy in 2020, contributing $9.6 billion.

As India ventures closer to uncovering the mysteries of space, it’s worth exploring the 10 Indian space tech startups poised to shape the future of this burgeoning sector in the country’s growth narrative.

Pixxel

Pixxel, a space technology startup founded in 2019 by Awais Ahmed and Kshitij Khandelwal during their time at BITS Pilani, focuses on developing high-resolution Earth observation satellites. Equipped with hyperspectral sensors, Pixxel’s satellites collect diverse wavelength data about Earth’s surface, enabling monitoring of critical factors like crop health, deforestation, and water quality.

Pixxel launched its first hyperspectral imaging satellite ‘Shakuntala’. The satellite transmits essential data concerning climate change assessments, including information on deforestation, ice cap melting, gas leaks, and crop health. The startup has secured over $36 million in funding from investors including Google, Omnivore VC, and Radical Ventures. They’ve also created a user-friendly software platform for data visualisation and analysis and have published research papers on the versatile applications of hyperspectral data.

Skyroot Aerospace

Skyroot Aerospace is an Indian private aerospace manufacturer and commercial launch service provider headquartered in Hyderabad, Telangana. The company was founded in July 2018 by former engineers and scientists from ISRO.

The company’s mission is to “open space for all” by developing affordable and reliable launch vehicles for small satellites. Skyroot is developing a series of launch vehicles called the Vikram series, which will be used to launch satellites into low Earth orbit (LEO) and sun-synchronous orbit (SSO).

The first launch vehicle in the Vikram series, the Vikram-1, is scheduled to be launched soon. Vikram-1 will be a three-stage solid-propellant launch vehicle with a payload capacity of 500 kilograms. Skyroot has also developed a cryogenic engine, which is currently undergoing testing. The company has raised over $51 million in funding to date.

Dhruva Space

Dhruva Space Private Limited is an Indian private aerospace manufacturer headquartered in Hyderabad, Telangana. Founded in 2012 by Sanjay Srikanth Nekkanti, the company is engaged in the development of small satellites in the commercial, governmental and academic markets. It provides full-stack space-engineering solutions across launch, space and ground segments – namely, the building, launching and operation of satellites.

Dhruva Space offers a range of satellite platforms, from small CubeSats to larger microsatellites. The platforms are designed to be modular and adaptable, so they can be customised to meet the specific needs of each customer.

Agnikul Cosmos

Agnikul Cosmos is an Indian private space launch vehicle startup company headquartered in Chennai, Tamil Nadu. It was founded in 2017 by Srinath Ravichandran and Moin SPM. The company is developing a small, fully 3D-printed rocket designed to launch small satellites into low Earth orbit.

In 2022, the company successfully test-fired its first 3D-printed rocket engine. They inaugurated India’s first-ever launchpad designed and operated by a private player in 2022. The company has raised a total of $34.8 in funding.

Bellatrix Aerospace

Bellatrix Aerospace is an Indian private aerospace manufacturer headquartered in Bangalore, Karnataka. It was founded in 2015 by Rohan M Ganapathy and Yashas Karanam. The company is developing a small satellite launch vehicle called the Chetak, which is designed to launch small satellites into low Earth orbit.

The startup has developed four different types of thrusters which are one of a kind. They hold the global patent for these thrusters and have received an order from Indian Space Research Organisation (ISRO). The company has a total of $11.3 million in funding. In June 2023, they signed a contract with the Government of Karnataka to set up a $76 million factory in Bangalore which will focus on environmentally friendly propulsion technologies for small satellites.

Astrome Technologies

Astrome Technologies, a deeptech startup founded in 2018 by Neha Satak and Prasad HL, accelerates 5G and rural telecommunication infrastructure deployment using patented millimetre-wave E-band radios and satellite communication products.

Astrome’s products find application in 5G backhaul, rural connectivity, and satellite communication. They facilitate 5G base station internet connectivity in rural areas, bridging the digital divide, and supporting satellite-based services such as weather forecasting and disaster management. The company has secured over $10 million in funding from investors like Accel Partners and Sequoia Capital India, with headquarters in Bengaluru, India, and international offices.

Aadyah Aerospace

Aadyah Aerospace, founded in 2016 by Shaju Stephen and headquartered in Bengaluru, specialises in aeronautics, space, and defence engineering and technology solutions. This startup is dedicated to integrating AI to transform computer vision, communication, and motion control.

Operating within both the space and aerospace sectors, Aadyah Aerospace focuses on self-designed satellites, launch vehicle subsystems, and drones. The startup’s primary emphasis is on the production of advanced electro-mechanical actuators, control actuation systems, and electro-optic systems for missiles and launch vehicles. Notably, they have successfully developed a cube set dispenser designed to securely hold satellites in position during launches until their deployment into Low Earth Orbit (LEO).

Within a year of its establishment, Aadyah Aerospace secured nearly $6.12 million in funding from the US-based Keiretsu Forum.

Vasundhara Geo Technologies

The company was established in 2017 by Aditya Tekale, focuses on data mining. The startup specialises in acquiring and analysing data from satellites, aerial platforms, and field sensors. Using proprietary deep learning algorithms, Vasundharaa efficiently handles extensive and intricate datasets, providing rapid and insightful outcomes.

The company comprises a team of data analysts, software developers, geologists, and business professionals who have completed over 75 projects across various sectors, including agriculture, environment, defence, disaster management, and urban development. Vasundhara Geo Technologies effectively caters to the specific needs of its clients.

SatSure

SatSure, established in 2017 by Prateep Basu, Rashmit Singh Sukhmani, and Abhishek Raju, operates from Bengaluru as a space tech startup. It utilises satellite data to provide ‘decision intelligence’ services, primarily serving the BFSI, agriculture, and infrastructure sectors.

The startup emphasises making space data easily accessible to all users and offers a SaaS product that enables financial institutions to extend on-demand credit to farmers. In a significant development, SatSure secured investments from banking giants ICICI Bank, Kotak Mahindra Bank, and HDFC as part of its $20 million funding round this year. The company plans to utilise these funds to establish a fleet of four high-resolution data-producing satellites by 2024.

Digantara

Founded in 2018, Bengaluru-based startup Digantara focuses on sustainable space practices and space debris detection. Anirudh Sharma, Rahul Rawat, and Tanveer Ahmed founded it with the goal of creating an Indian ecosystem for small satellites. They recently launched the Pushan-Alpha satellite for space weather testing. Digantara is also working on a Space Mission Assurance Platform to manage space operations and traffic. The company is funded by Kalaari Capital, Peak XV Partners and Global Brain and has raised a total funding of $12.5M over three rounds.

The post Top 10 Space Tech Startups in India in 2023 appeared first on Analytics India Magazine.