Laxman Vijay

twitter

facebook

instagram

linkedin


Physicists from South Korea have developed a new algorithm that can design a structure that follows along any given path. The idea is based on the simple realization that a spherical clay could be subtly deformed to follow along a random path.

The research team started by envisioning a sphere rolling down a ramp. If the sphere is imagined to be made of clay, it can be manipulated (deformed) as it rolls to make it conform to a given path. If the sphere is then rolled down the ramp again, it will follow the previous path due to the new deformities in its shape. The researchers noted that the paths that could be taken by the sphere could be nearly limitless due to the nearly limitless possible deformations.

That realization led them to wonder if the deformations that form in such a sphere could be corelated mathematically with its path. And if so, if such math could be used to create an algorithm that could be used to 3D print a sphere with deformations that would force it to follow a predetermined path.

Turns out it is possible. The team deviced an algorithm that computes a shape by analyzing a given path. The computed shape is then 3D printed. They named the objects trajectoids. Each had a solid metal ball-bearing inside to give it weight. They also found that they could create trajectoids that traveled over a given path twice, and named them "two-period trajectoids".

## What are the applications?

Turns out this new method could be used in robotics applications and also in physics research associated with the angular moment of an electron—or in quantum research centered around the study of evolution of a quantum bit.

<iframe width="560" height="315" src="https://www.youtube.com/embed/2lW9HznqsVY?si=NdaLqN4Sn4WdNIDK" title="YouTube video player" frameborder="0" allow="accelerometer; autoplay; clipboard-write; encrypted-media; gyroscope; picture-in-picture; web-share" allowfullscreen></iframe>

## Code source:

The team also published a Google Colab for reference: https://colab.research.google.com/drive/1XZ7Lf6pZu6nzEuqt_dUCHormeSbCCMlP. The original paper can be accessed in [Nature](https://www.nature.com/articles/s41586-023-06306-y.epdf?sharing_token=MfjPA0Uduzd60wRcg6kvYtRgN0jAjWel9jnR3ZoTv0PI2oLqSz3ENBVadr6bTqqLXcnyfhIenA1AWB-lO_690iJFCALE1LSm57zc7zJ_0tgwc8etNM2RCelBtq8HIqT9EUbdWrgJv4WS2TN3vUg7dNO-otq2THip68dw4Mli0a8%3D) where they describe the process and the applications.

Solid body trajectoids roll along desired pathways

Trajectoids could introduce a new math field


If you are developer, you would have that natural instinct to automate everything that comes along the way. Create a folder? automate. Open browser and Spotify when opening vs code? automate. But. Its not that easy and you know it. We have a couple of options in Mac like Shortcuts and Automator. However, these are UI driven. I know your programmer mind is screaming, “who wants an UI automation tool?”.

But I don’t like going all in on a Python script and running it every time either. Fair enough.

Enter [ScriptKit](https://www.scriptkit.com/)… The very first time I saw ScriptKit and its capabilities, I was completely blown away. Its in this sweet spot between a complete scripting language and a full blown UI automator.  It has endless possibilities on what you could automate with it. The cherry on top? Its in Typescript. Its amazing. 

ScriptKit itself is based on Google’s [zx](https://github.com/google/zx) which is a cli executable for javascript files.

![https://mcusercontent.com/d3088c0b6f03798a651d40fff/images/84ed56b6-98e6-d1cd-a5fe-0bb739554c6a.jpeg](https://mcusercontent.com/d3088c0b6f03798a651d40fff/images/84ed56b6-98e6-d1cd-a5fe-0bb739554c6a.jpeg)

In this article, I will be showing 2 examples which are both cool and helpful to get started in ScriptKit.

## Before that,

Here is a very simple hello world script:

```
// Name: Display HTML

import "@johnlindquist/kit"

await div(`<h1>Hello World</h1>`)
```

## Example 1

### Open favourite sites in a click

Opening your favourite sites should be a single one click process and must not involve several steps. Here is a way to achieve it:

```tsx
// Name: Open Favorite Sites

import "@johnlindquist/kit"

try {
    let path = await arg("Type a site to open", [
        {
          name: "Youtube Music",
          description: "Opens YT music in a browser window",
          value: "https://music.youtube.com",
        },
        {
          name: "Pocket",
          description: "Opens Pocket in a browser window",
          value: "https://getpocket.com/saves",
        },
        {
          name: "Archivorous",
          description: "Opens Archivorous in a browser window",
          value: "https://archivorous.com",
        },
      ])

    $`open ${path}`
} catch (e) {
    log(e)
}
```

The script is simple, I define a bunch of sites and open the one I selected using the `zx $` command.

If you don’t believe me about ScriptKit, install and give this script a try with your own favourite sites. You will fall in love ❤️

## Example 2

Are you a fan of smart home devices? You will love this one. Let’s use ScriptKit to automatically turn on/off the smart lights.

One of the best things about ScriptKit is its ability to make HTTP request. Although controlling smart devices is not natively possible in ScriptKit, we can utilise the ever amazing [IFTTT](https://ifttt.com/) to achieve this.

But first, there are a couple of prerequisites: 

- You must have IFTTT setup without your smart device provider ( for example: Philips). The webhook provides complete control over the device. Careful with it.
- You must have a webhook IFTTT action created like this:

![https://mcusercontent.com/d3088c0b6f03798a651d40fff/images/a1cca452-426d-0db6-3eab-3446a3452aa9.jpeg](https://mcusercontent.com/d3088c0b6f03798a651d40fff/images/a1cca452-426d-0db6-3eab-3446a3452aa9.jpeg)

Now you can use the script below:

I am using IFTTT free version and so I cannot parse the incoming json in the webhook for dynamically controlling the lights. (But if you do have a pro version, you can use it to write javascript in IFTTT console and dynamically control which light is triggered in a single webook).

But for my purposes, I have created 6 webhooks and integrated them with ScriptKit:

```tsx
// Name: turn on or off smart lights

import "@johnlindquist/kit"

try {
    let selectedLight = await arg("Type a site to open", [
        {
          name: "Playroom on",
          description: "Turn on the playroom light",
          value: "playroom_lights_on",
        },
        {
          name: "Playroom off",
          description: "Turn off the playroom light",
          value: "playroom_lights_off",
        },
        {
          name: "Bedroom on",
          description: "Turn on the bedroom light",
          value: "bedroom_lights_on",
        },
        {
          name: "Bedroom off",
          description: "Turn off the bedroom light",
          value: "bedroom_lights_off",
        },
        {
          name: "Living room on",
          description: "Turn on the living light",
          value: "livingroom_lights_on",
        },
        {
          name: "Living room off",
          description: "Turn off the living light",
          value: "livingroom_lights_off",
        },
      ])

    await post(`https://maker.ifttt.com/trigger/${selectedLight}/json/with/key/<your key>`)
} catch (e) {
    log(e)
}
```

Now if you invoke the script, voila! 

The light turns on like magic. No voice commands, no mobile app, just from your computer without even taking your hands off the keyboard.

Hopefully, these examples are inspiring enough to explore ScriptKit. There is also a silent hero: IFTTT which performed all the heavy lifting for us.

Integrate ScriptKit with other automation services and create an unforgetable experience

Automate your life with Typescript and ScriptKit


Last month Meta [announced they are releasing a new LLM model](https://www.archivorous.com/posts/meta-announces-llama-llm-model) for research purposes. The model named LLaMA(Large Language Model Meta AI) is a state of the art LLM to help researchers run large models in a local environment (possibly in a single machine) to impact various research areas in the LLM domain.

This week Bulgaria based ****[Georgi Gerganov](https://github.com/ggerganov)** has released a [repo](https://github.com/ggerganov/llama.cpp) to execute the model in a M1 Mac. The port called as LLaMA.cpp uses 4 bit quantization to reduce the memory requirements of the model and run in a single Mac device. 

Running the actual LLaMA requires the following steps mentioned in the official repo: https://github.com/facebookresearch/llama. A request must be made to Meta to download the weights for the model. [Here is the official Google form from Meta](https://docs.google.com/forms/d/e/1FAIpQLSfqNECQnMkycAp2jP4Z9TFX0cGR4uf7b_fBxjY_OjhJILlKGA/viewform?usp=send_form) to request to download the weights.

Although the weights have leaked online. It is not legal to download and use this for commercial purpose. Use this magnet to download the weights:

```tsx
magnet:?xt=urn:btih:b8287ebfa04f879b048d4d4404108cf3e8014352&dn=LLaMA&tr=udp%3a%2f%2ftracker.opentrackr.org%3a1337%2fannounce
```

> Note: The magnet above is posted by one of the original requesters to which Meta has sent a download link. Technically, it is still not legal to download files that is intended for use by someone else but it should be fine for experiments and never for commercial use.
> 

> Refer LLaMA model card for info: [llama/MODEL_CARD.md at main · facebookresearch/llama · GitHub](https://github.com/facebookresearch/llama/blob/main/MODEL_CARD.md)
> 

Here are the steps to run the model after you obtained the weights:

- Clone the repo:

```
git clone https://github.com/ggerganov/llama.cpp
cd llama.cpp
make
```

- Place the weights in a model folder: (obtained from above methods)

```tsx
ls ./models
65B 30B 13B 7B tokenizer_checklist.chk tokenizer.model
```

- Install dependencies:

```tsx
python3 -m pip install torch numpy sentencepiece
```

- Convert to ggml format: (which is a tensor format developed by the same author)

```tsx
python3 convert-pth-to-ggml.py models/7B/ 1
```

- Quantize:

```tsx
./quantize.sh 7B
```

- Run inference:

```tsx
./main -m ./models/7B/ggml-model-q4_0.bin -t 8 -n 128
```

- Profit!

## The above steps are just too much!

If you feel you don’t want to hustle with the above steps, there is a simple alternative in this repo: [cocktailpeanut/dalai: The simplest way to run LLaMA on your local machine (github.com)](https://github.com/cocktailpeanut/dalai)

Simple run:

```tsx
npx dalai llama
npx dalai serve
```

- Visit [http://localhost:3000](http://localhost:3000/)

Above two commands do the following:

1. First installs the 7B module (default)
2. Then starts a web/API server at port 3000

Interesting to watch what people come up with using LLaMA!

It is now possible to run Meta's LLaMA LLM model locally in a M1 Mac!

Run Meta’s LLaMA locally in a Macbook


[Vercel](https://vercel.com) has been continuously updating and innovating their product lineups. From introducing a [scheduler last month](https://vercel.com/guides/how-to-setup-cron-jobs-on-vercel) to introducing [Next 13.2](https://nextjs.org/blog/next-13-2) - the latest stable version of Next.js, they are on a roll. And now they have announced the latest interesting update on one of their products.

Turborepo, the build system from Vercel is migrating from [Go](https://go.dev/) to [Rust](https://www.rust-lang.org/) incrementally. Although Go is still a integral part of the tool, it is slowly migrating away from it. One of the most important aspects of Turborepo is the support for [monorepos](https://monorepo.tools/).

Turborepo improves development speeds by offering multiple features like incremental builds, parallel execution and remote caching.

Turborepo is inspired from [esbuild](https://esbuild.github.io/), the awesome build tool for javascript written in Go. Naturally Vercel chose Go as their language for Turborepo.

Language migration is a demanding task. There's *a lot* to consider and the decision shouldn't be taken lightly. But instead of simply comparing the pros, cons and other aspects of a language (those doesn’t matter in a large scale most of the time), it is important to consider certain design choices and the scenarios the language is envisioned to be used for.

Go's strength is network computing in data centers and it **excels** at this task, powering these workloads at the world's largest scales. The goroutine-per-request model, Context API, and the standard library inclusion of server infrastructure is testament to this community focus. Go is also particularly simple in its syntax. Although, sometimes the syntax can be quite limiting and weird, it works most of the time.

The Turborepo team points out the same as their reason for the switch: “Additionally, Go favors simplicity over expressiveness. A side effect of that decision means more errors are caught at runtime where other languages might catch them at compilation. With a service running in a data center, you can roll back, fix, and roll forward at your convenience. But, when building software that users install, the cost of each mistake is higher. For us, it's worth using tools that prioritize up-front correctness. We fully recognize the mismatch of **Go's priorities** and **what we are prioritizing** as a problem that we created for ourselves to solve.”

That’s quite an interesting case to know. But does rust emphasize on compile time errors. **You bet!**

Unlike Go, which is focussed on networks, servers and large scale systems, Rust focusses on correctness over abstraction which provides a lot more control in aspects like process management, file systems, os, etc. 

Since being a software that is shipped to client devices, it makes sense.

“Rust's type system and safety features allow us to put guardrails in place in our codebase where we need them. The language's expressiveness allows our developers to encode constraints that catch errors at compile time rather than in GitHub issues.”

One more reason is the ability to interop with C/C++. A majority of low level libraries are still developed and maintained in C and C++. But newer developers want a safe language and also some ability to interface with those languages. Rust provides exactly that.

Rust has an unsafe alter ego is that the underlying computer hardware is inherently unsafe. If Rust didn’t let you do unsafe operations, you couldn’t do certain tasks.Rust has a FFI interface. It provides a keyword “extern” to allow rust code to invoke C code. Here is an example from the [rust book](https://doc.rust-lang.org/book/ch19-01-unsafe-rust.html#using-extern-functions-to-call-external-code):

```
extern "C" {
    fn abs(input: i32) -> i32;
}

fn main() {
    unsafe {
        println!("Absolute value of -3 according to C: {}", abs(-3));
    }
}
```

## Rust makes us happy

Another important aspect the team provides is since Rust allows them to be flexible and does not get in their way, it makes the team happy. It is not unique to Turborepo team. In fact, Rust is the most desired language for the past 4 years in [Stack Overflow surveys](https://insights.stackoverflow.com/survey).  

Rust finds its way into a majority of web and other software tooling these days partly because of the correctness and dev satisfaction.

Let’s see how this turns out for the Turborepo team.

Here is the announcement blog: [https://vercel.com/blog/turborepo-migration-go-rust](https://vercel.com/blog/turborepo-migration-go-rust)

The build system is starting to incrementally adopt Rust in their project

Turborepo migrates from Go to Rust


Large language models like ChatGPT and BARD are trained from a huge corpus of real world data. These are mainly extracted from the internet, books, wikipedia and by generally crawling websites. And so, naturally these models reflect what they have been trained on.

They excel in everything their source data excelled at. Including bias and stereotypes. Even the AI bots think they are biased. 

From ChatGPT, “As an artificial intelligence language model, I am designed to provide unbiased responses to questions and queries. My responses are generated based on the information I have been trained on, which includes a vast range of text from various sources. However, it's possible that my responses may reflect any biases present in the training data or the way questions are phrased. In any case, I strive to provide objective and informative answers to the best of my ability.”

So its clear that even the LLMs are aware they may be biased. But is there a fix for this?

## Is it that important?

Absolutely.

- There have been several examples in the past that AI models have exhibited racial discrimination towards black people and some sorts of gender discrimination towards woman.
- Models trained on data from news articles and other journals may include gender biases.
- Criminal justice AI models, oversampling particular areas may result in more data for crime in that area, which could lead to more enforcement.
- It was found that more searches containing the term “arrest” came up when African-American-identifying names were searched than for white-identifying names.
- With professions, a language model (which is biased) thinks that “flight attendant,” “secretary,” and “physician’s assistant” are feminine jobs, while “fisherman,” “lawyer,” and “judge” are masculine. Concerning emotions, a language model thinks that “anxious,” “depressed,” and “devastated” are feminine.

For an indepth talk on the seriousness of bias, here is a lecture from ML scientist Jeremy Howard: https://www.youtube.com/watch?v=5_xFdhfUnvQ&list=PLfYUBJiXbdtSyktd8A_x0JNd6lxDcZE96&index=12

## How could we fix bias?

Bias in an AI model is not easy to fix. There are several active researches going on to reduce bias. 

- One of the most important methods to fix bias in an AI model is increase diversity in the training data: This can be done by collecting data from a wide range of sources and ensuring that the data is balanced across different demographics.
- Penalising the models by introducing a human in the loop: This can be done by comparing the predictions of the model with real-world outcomes and checking if any particular groups are being unfairly impacted by the model. If found, then the model could be retrained again.
- The algorithm should also be fair: This is the idea of ensuring that AI models are fair and just to all individuals regardless of their race, gender, or any other demographic factor. One way to do this is by adjusting the algorithms used to train the model so that they do not unfairly favor one group over another. This can also be made possible by increasing the AI industry’s diversity. By making more diverse people work in the industry, we increase the perception of views and increase the chances of detecting biases and potentially reducing them.

## What are the recent advancements in this field?

Recently, [MIT has published a paper](https://news.mit.edu/2023/large-language-models-are-biased-can-logic-help-save-them-0303) for reducing model bias by introducing a logical layer to the model. 

“Current language models suffer from issues with fairness, computational resources, and privacy,” says MIT CSAIL postdoc Hongyin Luo, the lead author of a new paper about the work.

The team lead by Hongyin Luo has come up with the thought of introducing logical awareness in AI models. They trained a language model to predict the relationship between two sentences, based on context and semantic meaning, using a dataset with labels for text snippets detailing if a second phrase “entails,” “contradicts,” or is neutral with respect to the first one. Using this dataset — natural language inference — they found that the newly trained models were significantly less biased than other baselines, without any extra data, data editing, or additional training algorithms.

This model, which has 350 million parameters, outperformed [some](https://blog.google/technology/ai/lamda/) very large-scale language models with 100 billion parameters on logic-language understanding tasks. The team evaluated, for example, popular BERT pretrained language models with their “textual entailment” ones on stereotype, profession, and emotion bias tests. The latter outperformed other models with significantly lower bias, while preserving the language modeling ability.

The “fairness” was evaluated with something called ideal context association (iCAT) tests, where higher iCAT scores mean fewer stereotypes. The model had higher than 90 percent iCAT scores, while other strong language understanding models ranged between 40 to 80.

“Although stereotypical reasoning is a natural part of human recognition, fairness-aware people conduct reasoning with logic rather than stereotypes when necessary," says Luo.

"We show that language models have similar properties. A language model without explicit logic learning makes plenty of biased reasoning, but adding logic learning can significantly mitigate such behavior. Furthermore, with demonstrated robust zero-shot adaptation ability, the model can be directly deployed to different tasks with more fairness, privacy, and better speed.”

We are still far away from eliminating bias completely in the AI models. Although research like these are a positive step in the right direction.

With bias being a serious issue in several AI models, what is the new research to fix it?

How can we fix bias in Large Language models?


Have you ever thought of why did AI became a mainstream technology in the past 10 years although it has been tried and failed several times in history?

The answer is twofold. One is the vast availability of data after the internet era and the other is the advanced hardware capable of processing that data.

Today let’s look at one such amazing technology which greatly helped AI in reaching its current shape — Nvidia’s CUDA.

CUDA is a parallel computing platform and programming model developed by NVIDIA for general computing on its own GPUs (graphics processing units). CUDA enables developers to speed up compute-intensive applications by harnessing the power of GPUs for the parallelizable part of the computation.

GPUs are very old. In fact they are invented around the same time mainstream personal computers itself were getting started — like the 70s.

NVIDIA started trying to compete in the 3D accelerator market with weak products, but learned as it went, and in 1999 introduced the successful GeForce 256, the first graphics card to be called a GPU. 

Although the first ever GPU was launched during 1999, its only purpose was to improve performance during gaming. 

It was only on 2006, GPUs were experimented for other purposes in engineering, simulation, etc. But in order to do this, computer programmers have to access GPU to write programs that work on them. That became possible after Nvidia released its interface called CUDA (Compute Unified Device Architecture) as a platform in C (programming language).

It became a huge paradigm shift for compute intensive workloads. But the problem is, CUDA is only for Nvidia GPUs. In an attempt to break this, AMD released OpenCL as an alternative in 2009, but it didn’t do well.

CUDA became supported in every mainstream industry — Finance, Weather modelling, Defence, Manufacturing, Media, Medical imaging and of course AI and deep learning. 

Basically anything that requires compute intensive tasks became offloaded to the GPU.

But how could GPUs improve performance of normal computer programs other than graphic rendering?

![CPU vs GPU](https://mcusercontent.com/d3088c0b6f03798a651d40fff/images/b5043d70-11a6-40ba-0a50-60fa2290420f.png)

Basically, a CPU has something called as an ALU - Arithmetic and Logical Unit which performs mathematical operations. The problem is, a CPU cannot parallelize well. It is designed to be a decision making system and not a computation platform. Here’s where GPU comes into the picture. They have so many mathematical units - several 1000s of them. But they can only perform simple mathematical operations in extreme  parallel speed.

Thus, whenever, parallel mathematical operations like Matrix multiplication and addition are involved, the GPUs can vastly outperform the CPUs. And that’s why, image processing and graphic rendering (which is just an RGB matrix) is very fast on a GPU.

Deep learning uses this idea and converts every input into a matrix and sends it to the GPU for performance gains.

Explaining Nvidia's CUDA in a simple manner

An ELI5 explanation of CUDA


Ever wondered how NPC characters in games work?

Every game these days has a mechanism to introduce NPC characters, villains, bosses, animal friends, etc into their games these days. 

Like for example, if you have played Far cry 5, there is Boomer (which is the cutest).

But ever wondered what goes behind these NPC characters that make the game so much interesting?

That’s right! These are all AI systems trained beforehand.

Let’s look at one of the popular training mechanisms and a historical game event that took place.

## Deep Reinforcement Learning

There is this idea of reinforcement learning in AI where in an AI agent is treated with rewards if it performs as expected and is penalised if it is not performing as expected. This is not new. It is a mechanism that prevailed from the 90s.

![RL Agent](https://mcusercontent.com/d3088c0b6f03798a651d40fff/images/3acf73be-1621-9e8c-2945-1e901ddd26a1.jpeg)

But what is new is deep learning integrated into reinforcement learning and transformed into deep reinforcement learning.

Deep learning is an idea in which a large number of input training data (like images, videos, text, etc) is fed into a system and generates a output by simply multiplying the inputs with a weight. The value of weight is trained and improved over time.

The system is called a deep learning model. There are several architectures and patterns for these models to generate different types of responses. One of the famous examples is the ChatGPT. It uses a model architecture called as GPT (Generative Pre trained Transformer) developed by OpenAI which itself was inspired by an interesting architecture called as Transformers released by Google.

Back to DRL, now combining deep learning and reinforcement learning is not difficult if you think about it. (Or at least from a theoretical standpoint)

A deep learning model can help the AI agent see the world (its environment) more precisely. Hear the environment more precisely. Understand the environment more precisely. 

For example, a vision model can help identify an object present in front of the game AI (like a sword present in front of it). This vastly improves the ability of the game agent to improve its actions. 

This same idea can not only be applied to game agent, even self driving cars like Tesla, Waymo, Zoox, etc. are all based on the this fundamental principles. Although these systems can be more sophisticated because of the complexity of the real world than a simulated game environment. 

But with that gentle introduction, here are some ways in which we can train our own systems.

There is a ML agent training system within Unity called as ML agents ([Build More Engaging Games with ML Agents | Unity](https://unity.com/products/machine-learning-agents))

Check this blog for more explanation on ML Agents: [Training intelligent adversaries using self-play with ML-Agents | Unity Blog](https://blog.unity.com/technology/training-intelligent-adversaries-using-self-play-with-ml-agents)

OpenAI has something called as OpenAI gym. ( Back in 2022, they moved their reinforcement learning tools to a new non-profit organisation called Farama). Here is the link for that: [Gymnasium Documentation (farama.org)](https://gymnasium.farama.org/)

Gym is amazing because of the bootstrapped nature of their environments. All it takes is a 6 line code to simulate a 2d lunar lander.

```python
import gymnasium as gym

env = gym.make("LunarLander-v2", render_mode="human") 
observation, info = env.reset() 

for _ in range(1000): 
    action = env.action_space.sample()
    observation, reward, terminated, truncated, info = env.step(action) 
    if terminated or truncated: 
        observation, info = env.reset() env.close()
```

## AlphaGo

Although there are several tools like the Gym and ML Agents as mentioned above, it is all relevant these days only because of a historical game event that took place back in 2016.

In march 2016, Lee Sedol, an 18 times world champion in the ancient Chinese game of Go would be challenged by Google’s DeepMind for a match. Little at that time did Sedol knew that that match would be written in history for it being the first one to host an AI agent beating a Go world champion. 

Unlike Chess, Go was more difficult and had unimaginable complications and was never beaten by an AI before. (Chess was first beaten by AI by IBM DeepBlue against Garry Kasparov).

Although Sedol beat AlphaGo once, AlphaGo beat him 4 times and won the match in a clean 4-1 victory. Since then, Google’s DeepMind was the all the rage everywhere and it popularised Deep reinforcement learning to the masses.

Learn more about it here: [The Challenge Match (deepmind.com)](https://www.deepmind.com/research/highlighted-research/alphago/the-challenge-match)

An ELI5 introduction to deep reinforcement learning

An ELI5 introduction to Deep reinforcement learning


We all know the ongoing AI wars that Microsoft and Google have started. The hype began last year with the advent of Generative AI tools like DALL-E and ChatGPT by OpenAI. These technologies shifted the landscape drastically from other overhyped technologies like blockchain and web3 (which still searches for a problem to solve) to AI. Several new AI influencers, AI artists, AI writers, AI tools, AI logo generators and a lot other utilities were created. With only a short prompt, DALL-E can generate amazing images. Like for example as provided in [AssemblyAI blog](https://www.assemblyai.com/blog/how-dall-e-2-actually-works/), “a bowl of soup that is a portal to another dimension as digital art”

[DALL-E generated images](https://mcusercontent.com/d3088c0b6f03798a651d40fff/images/c155b2a6-74ba-3616-772f-fc3b6b470564.png)

But behind all this amazing technology is an amazing history of over 50 years. Over this period several people and companies have tried so hard to make this possible. 

It all started way back even before the first personal computers starting hitting people’s homes. In 1943, a seminal paper published by Warren McCulloch and Walter Pitts on artificial neurons is the first to explore this topic. Here is the paper if you wish to read: [A logical calculus of the ideas immanent in nervous activity | SpringerLink](https://link.springer.com/article/10.1007/bf02478259)

Following their paper, in 1950, the genius scientist Alan Turing published a method to analyse and measure “computing intelligence” called as Turing test. It is relevant even today. 

Following that, in 1956, John MacCarthy coined the term “Artificial Intelligence” at the historical [Dartmouth conference](https://en.wikipedia.org/wiki/Dartmouth_workshop). It was at this moment that AI gained its name, its mission, its first success and its major players, and is widely considered the birth of AI.

Remember, it was a time, old languages like FORTRAN were developed and companies like Apple and Microsoft didn’t even exist. IBM was the top tech company. 

So many successful AI projects were developed till 1974. One of them is the famous [WABOT-1](https://www.humanoid.waseda.ac.jp/booklet/kato_2.html). But after 1974, the first AI winter began. Investors stopped believing in the potential of AI because most of the systems at that time were overhyped and internally they were just programmed if else statements.

Again in 1980, a conference held at Stanford university, sparkled the interest for AI yet again. This time, AI came back with Expert systems. It was more or less the same if else statements but more sophisticated. It was doomed to fail.

The second AI winter began in 1987.

After several years, in 1997, [IBM’s DeepBlue](https://www.ibm.com/ibm/history/ibm100/us/en/icons/deepblue/) - a chess AI, for the first time defeated the then world champion in chess, Garry Kasparov. It was at that moment, everyone started looking into AI again. But this time it was different. Several new algorithmic approaches were created. This includes the idea of Machine learning, [Back propagation](https://www.nature.com/articles/323533a0), etc.

After 2000, several practical AI systems that are focussed on a specific task were developed. Technology became sufficiently advanced to collect large data and process them.

Several companies like Google, Facebook, Apple, Amazon, Microsoft, etc. started investing in AI and it became integrated in commercial products.

And fast forward 20 years, here we are today with advanced AI systems paint for us, write for us, talk and book an appointment at a saloon for us, even drive us to office. We are so much invested into AI than we realise. And with the rate, AI is advancing it is hard to imagine the innovations that will come out this year.

A short summary of the history of the revolutionary AI technology

History of AI

Your privacy is important to us. We promise not to send you spam!

Get inspired from our coverage of the latest trends and breakthroughs in the world of gaming and AI.

Trajectoids could introduce a new math field

Recent stories

Automate your life with Typescript and ScriptKit

Run Meta’s LLaMA locally in a Macbook

Turborepo migrates from Go to Rust

How can we fix bias in Large Language models?

An ELI5 explanation of CUDA

An ELI5 introduction to Deep reinforcement learning

Trajectoids could introduce a new math field

Automate your life with Typescript and ScriptKit

Run Meta’s LLaMA locally in a Macbook

Popular tags

Follow us

Learn the newest gaming tech updates with our weekly newsletter