Laxman Vijay

twitter

facebook

instagram

linkedin

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.

Learn the newest gaming tech updates with our weekly newsletter


Bard is Google’s version of conversational AI similar to ChatGPT which has taken the internet by storm over the past few months. This is due to the nature of human like conversational abilities by these AI systems, more and more people finding it using for a variety of tasks.

When it comes to conversational AI, Google is undisputed given the amount of research and development they have done over the years in this field. Bard is the next addition in their lineup. Although given the timing, Bard is simply recognised as a competitor to ChatGPT rather than a flagship product from Google.

Bard is based on the Language Model for Dialogue Application or LaMDA which was released 2 years also by Google. 

“Bard seeks to combine the breadth of the world’s knowledge with the power, intelligence and creativity of our large language models. It draws on information from the web to provide fresh, high-quality responses” according to the [announcement blog](https://blog.google/technology/ai/bard-google-ai-search-updates/) from Google.

This new product adds to Google’s portfolio of AI models including LaMDA, PaLM, Imagen and MusicLM. All these provides more tools to enhance generational AI and impacting the creativity space. 

As of now, there is no demo version of Bard similar to how [ChatGPT has one.](http://chat.openai.com) However, Google says, these new features will be integrated into Google search soon. 

Also, Google plans to release developer APIs from next month starting with Language API powered by LaMDA and followed by other models soon.

Google introduces Bard which is a conversational AI similar to ChatGPT.

Google introduces Bard, Its answer to ChatGPT


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


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?


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


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

Ai

An ELI5 introduction to Deep reinforcement learning

History of AI

How can we fix bias in Large Language models?

Run Meta’s LLaMA locally in a Macbook

An ELI5 explanation of CUDA

Follow us

Most read articles

Learn the newest gaming tech updates with our weekly newsletter