DEV Community: Arkadeep Nag

Artificial Learners, Not Artificial Intelligence: Why Bigger Data Isn't Enough

Arkadeep Nag — Mon, 14 Oct 2024 07:57:36 +0000

In recent years, we’ve seen incredible advancements in machine learning. From language models that can generate realistic conversations to vision systems capable of identifying objects with remarkable accuracy, the progress is undeniable. But, as these systems grow larger and more complex, it’s becoming clear that we aren’t on the path to true artificial general intelligence (AGI)—the kind that can reason, understand, and adapt like humans. Instead, we are building "artificial learners"—machines that excel at learning from data but lack genuine understanding or intelligence.

More Data, Less Understanding

A defining trend in AI development has been to make systems bigger by feeding them more data. Take GPT-3, for example, a language model with 175 billion parameters, trained on hundreds of gigabytes of text data. This scale allows it to generate fluent, human-like language. But beneath the surface, these systems don't actually understand the world the way humans do.

Research has shown that simply scaling up models with more data does not equate to deeper understanding. A study from OpenAI comparing GPT-2 and GPT-3 found that while larger models show improved performance on many benchmarks, they still struggle with tasks requiring reasoning, abstraction, or common sense. For instance, when asked simple logic puzzles or math problems, GPT-3’s performance is much worse than one might expect from a system with such vast resources. This suggests that adding more data doesn’t fundamentally change the nature of these systems—they remain statistical models, not true reasoning entities.

Moreover, the growth in model size has come with diminishing returns in terms of performance gains. The improvements from increasing the size of these models are getting smaller with each iteration. According to a study, while the largest models (with billions of parameters) outperform smaller ones, the performance increase is relatively modest given the huge increase in computational cost. This calls into question whether bigger models alone are the answer to developing more intelligent systems.

The Mirage of Intelligence

These systems can be impressive in specific tasks—completing text, identifying images, or even playing complex games like chess or Go—but this doesn’t imply they have any real understanding of what they’re doing. When interacting with them, the responses may seem intelligent, but that’s largely due to the vast amounts of data they’ve been trained on and their ability to mimic patterns found in that data.

For example, in a study from MIT, researchers demonstrated that language models like GPT-3 can be easily tricked by slightly altering questions or phrasing. Despite having access to vast data, these models often fail to grasp simple concepts or adapt to unexpected inputs. They don’t "understand" the context like a human would; instead, they rely on statistical correlations between words. When those correlations break down, so does the model’s performance. This shows that while these systems are adept learners, they lack the deeper reasoning required for general intelligence.

The Limits of Data-Driven Learning

Adding more data has also not solved issues related to bias, fairness, or robustness. Large models often inadvertently reinforce the biases present in their training data. A 2020 study by researchers at Stanford highlighted that language models trained on internet text reflect the societal biases found in those texts. For example, models trained on large datasets can produce biased or harmful outputs, simply reflecting the biases in the data they were exposed to, without any inherent "understanding" of the implications of those outputs.

Another limitation is the inability of data-driven models to transfer knowledge effectively to new, unseen tasks. A hallmark of human intelligence is our ability to apply knowledge gained in one domain to a completely different one. AI models, by contrast, are typically specialized to perform specific tasks they've been trained for. When presented with new tasks or environments, they often struggle. A 2022 paper from Google Research revealed that scaling up models doesn’t automatically make them better at generalizing to unfamiliar tasks. Despite training on vast amounts of data, these systems can fail dramatically when faced with scenarios outside their training distribution.

The Pursuit of AGI: A Misguided Path?

The pursuit of AGI—the kind of intelligence that mirrors human cognitive abilities—will likely not be achieved by simply scaling up data and models. Data-driven approaches, while powerful for specific tasks, do not lead to the kind of general reasoning, problem-solving, and understanding required for true intelligence. What we have today are highly specialized learners, capable of mastering certain tasks within narrowly defined domains, but unable to generalize their learning or engage in deeper cognitive functions.

In contrast, human intelligence is built on an understanding of the world, the ability to reason about causes and effects, and the flexibility to apply knowledge across contexts. Current AI models lack this adaptability. They are artificial learners—extremely good at learning from patterns in data—but they fall far short of true intelligence.

Moving Beyond Artificial Learners

The path forward in AI may not lie in simply building bigger models with more data but in developing new architectures that mimic the processes underlying human cognition. This might involve combining deep learning with other approaches like symbolic reasoning, causal inference, or even neuromorphic computing, which aims to replicate the structure of the human brain. These approaches could allow systems to not only learn from data but also reason, understand, and adapt to new and unforeseen challenges.

In conclusion, while the current wave of AI models has achieved impressive feats, we are not on the path to creating artificial general intelligence. Instead, we are refining artificial learners—systems that are excellent at processing and learning from data but fundamentally limited in their ability to reason, understand, or generalize. If we want to build machines that are truly intelligent, we’ll need to move beyond the paradigm of bigger data and start focusing on the deeper, cognitive processes that make human intelligence so unique.

References:

Brown, T. et al. (2020). Language Models are Few-Shot Learners. OpenAI.
Bender, E. et al. (2021). On the Dangers of Stochastic Parrots: Can Language Models Be Too Big? FAccT Conference.

Why seeing yourself in future after time travelling is impossible ?

Arkadeep Nag — Sat, 09 Jul 2022 10:33:56 +0000

How beautiful it would be if you can see what you will be doing in the future ?
Maybe you would take over SpaceX or would be the next big billionaire.

TV Shows show you so-

But here's the logical reality to it.
Maybe you are going in the future with a time machine and when you land there you saw the utopian future but its not having you. You are no where in the future except yourself.

You expectedto see yourself in a great position in the future but you cannot find yourself there in the future. What happened ?

Actually the thing is since you were time travelling you might have forgot that you were racing with time instead of building the future. You were going ahead of it. So when you reached there you didn't saw the future version of yourself.

Simply you can understand it like this :-

You are time travelling in the same universe therefore you cannot expect to see your dopleganger in the future.
You were travelling faster than the speed of light and that's why you reached in the future you were travelling with time.

Merge the points one and two :-
You donot have a dopleganger to replace you in the world when you are time travelling so who will you see when you go there , you weren't there to build your future , therefore you will only be able to see one version of yourself in the future and that's you.

How I am creating my own search engine

Arkadeep Nag — Fri, 25 Mar 2022 17:45:19 +0000

Creating a search engine from scratch

The basic function of a search engine is to search . But that basic function includes a lot of work in the background .
That include :

Crawling websites / Creating a software that goes through websites and get their data
More importantly get the legal permission of the website owner to allow us crawl their website
Creating a database
Creating ranking algorithms
Creating ML models for various purposes which includes understanding speech , understanding images , language and many more

Now no useful search engines in the world is open source so we cannot just use any code from someone else .
We had to begin from strach

Creating a Search engine from my experience

Steps for beginning the creation

Identify which form of database you want to use Either you can use a graph database , SQL database , NO SQL databas or just create a database with customisations yourself

Since no database system was totally free to use I created my own Database system which is partially based of Graph SQL and NoSQL .

Identify the programming language you will use for the crawling process

You have Python as one of the best option byut C or C++ is required for MapReduce algorithms in some cases
You can use simple modules already existing in python family or go around with Cython which I for myself used
Identify which language you are going to use for your frontend development

you can use C , C++ or Python as they would be compatible with all your frameworks and then use SWIG or Webassembly to convert it to JavaScript or
use JavaScript frameworks in which you may get problems to include your ML and AI models.I personally used the first option to include my ML models with ease
Defy algorithms and their respective flowcharts that you need to generate better search results. You may require atleast ten of them

1st for crawling the webpages
2nd for crawling the webpages through backlinks
3rd update the webpages frequently
4th Continuously run the crawlers
5th Identify elements from websites and classify them
6th How will your DB work
7th Connecting DB from many servers together
8th Responding to queries
Then your ML models
Your AI Models
How will you rank your search results
Query management
And many more
I personally wrote many . This part gives a bit of an headache

Begin with Frontend

The frontend will attract your users and force them to invite many . But your website is going to pull a lot of information and can slow down if it is made with high graphics . So make it minimalistic but beautiful

Creating the frontend first would also give you some relief from the headache of creating long algorithms

Create the crawler

Though I have used Cython ( C and Python )I would rather prefer others using python with third party frameworks - > Selenium and Beautiful Soup or Scrapy

Choose a Database

I created my own Database with some help of opensource GraphQl and NoSQl database .
I made it scalable so that it can handle many data and queries . It is also scalable . I used Ruby , Python and C for creating it . I am using 7 Server computers to host the db

It would be easy to query from NOSQl DB and Graph db ( from my experience )
But you can choose other DB . For free option you can use Firestore from Firebase it's simple and easy .

Building your server

If you are not using any cloud database and want to have your own server and DB use a Linux device and old PCs or if you have money buy some low end servers

Handling Pentabytes of data

My crawler uptill now has crawled 3M+ webpages and it has cached more than 156GB data . Every second 30+ webpages are added to the index . Google has stored 136Trillion + webpages and so you got the idea in no time you will have billions and billions of data to handle . So our database needs to be scalable . I have AI models to manage them and it has been made scalable so you have to make an idea to handle them

Algorithms for ranking your search results

The data you will get perquery will be huge if you have many pages indexed . So ranking them would be a factor . I didn't use the "PageRank" algorithm but devised my own . I have made the algorithm not to look after how many backlinks point to the page but I have used 8 parameters

You can break down a query for e.g.

This is a search results

In this search query which words have more emphasis it's the fourth and the last because the first three don't really matter much in a sentence while searching.

If any page has this two word they would be ranked based on how many times they are repeated .

For example we have 5 pages having search and results
1.A 2.B 3.C 4.D 5.C
And we have 2 pages each with only one of them so they will be ranked down

E 7. F

The first check will end here

The second parameter is in which pages the words are given more emphasis

For example if a word is in title of a webpage it will be given more emphasis than the webpage having it in its body

Suppose "A" has the words in body and "B" has the word in title

So now the ranking will change to

B 2. A

The third parameter will now intervene it will check how does the whole webpage relates to the user's query . Like location , mood ( mood detection algorithm ) , tone ( tone of the words ) and many other things
. Suppose the query is more related to the webpage on "C " more than "A" and "B"
New rankings ->

C 2. B 3. A

Fourth parameter will check the clicking ratio of that website on similar queries. For example if someone clicks "B" more than "C" when searching for related queries then the ranking of "B" will automatically increased

Being personal

The rest four and other topics are not possible to cover in single blog .
I have worked ver hard for the last 3 years for creating the search engine I hope you will like it when it launches this year. Now it's on the verge of being completed.

If you wanna see or experience an old build of the similar search engine with no algorithms and firebase database then go to https://dravel.herokuapp.com

Thank you very much for reading till last

Nothing

Arkadeep Nag — Sun, 26 Dec 2021 08:48:47 +0000

Creating a GUI Python App with Firebase SignIn - Python Firebase || GUI Python App

Arkadeep Nag — Fri, 20 Aug 2021 16:02:55 +0000

We will create a GUI APP with python with firebase login and signup functions .

On Sign Up --->

On Sign In-->

Step 1 --> The first step to do is to create a firebase project .
Go to the firebase console on https://console.firebase.com -> Then create a new project -> Go the project settings to check the config details . If you do not find them then create a new firebase web project .

Step 2 --> The second step is to create a new python file with the name firebase.py or main.py (name doesn't matter). Then use pip install pyrebase (For Windows).

pip install pyrebase

Step 3--> The third step is to install PyQt5 by using pip install pyqt5 (For Windows) -> Then install pip install pyqt5-tools (For Windows)

pip install PyQt5
pip install pyqt5-tools

from PyQt5 import QtCore, QtGui, QtWidgets
import sys
import pyrebase

Step 4 -- > Initialize Firebase with Pyrebase

config = {
    "apiKey": "AIzaSyDZw2TKNMPLkFBI7qPzklTGbd8bYkIyfUc",
    "authDomain": "py-firebase-f97fc.firebaseapp.com",
    "databaseURL": "https://py-firebase-f97fc-default-rtdb.firebaseio.com",
    "projectId": "py-firebase-f97fc",
    "storageBucket": "py-firebase-f97fc.appspot.com",
    "messagingSenderId": "130186938120",
    "appId": "1:130186938120:web:d8b87ef2a01af62dbf4ebd",
    "measurementId": "G-9R811DMZEL",
    "serviceAccount":".\py-firebase-f97fc-firebase-adminsdk-7w4qw-52ae79b7e5.json"
    }

firebase = pyrebase.initialize_app(config)

Step 5 --> Check whether there is already an user present or not

try:
    IsUser=user['userId']
except:
       IsUser = None

Step 6 --> On step 6 we start defining the auth

auth = firebase.auth()

Step 7 --> Now its the the time for creating a class and check if there is a user or not

class Ui_Dialog(object):
# if IsUser == None :

Step 8 --> We define the GUI . I have created it with Qt5 Designer , You can create your own or use my code for practice.


def setupUi(self, Dialog):
        Dialog.setObjectName("Python with Firebase")
        Dialog.resize(447, 621)
        self.gridLayout = QtWidgets.QGridLayout(Dialog)
        self.gridLayout.setObjectName("gridLayout")
        self.verticalFrame = QtWidgets.QFrame(Dialog)
        self.verticalFrame.setMinimumSize(QtCore.QSize(429, 300))
        self.verticalFrame.setObjectName("verticalFrame")
        self.verticalLayout = QtWidgets.QVBoxLayout(self.verticalFrame)
        self.verticalLayout.setObjectName("verticalLayout")

        self.lineEdit = QtWidgets.QLineEdit(self.verticalFrame)
        self.lineEdit.setMinimumSize(QtCore.QSize(300, 40))
        self.lineEdit.setMaximumSize(QtCore.QSize(500, 40))
        self.lineEdit.setStyleSheet("border-radius:2px;\n"
        "padding:2px;\n"
        "content:'Email';\n"
"border:1px solid #262626;")
        self.lineEdit.setObjectName("lineEdit")
        self.verticalLayout.addWidget(self.lineEdit, 0, QtCore.Qt.AlignHCenter)
        self.lineEdit_2 = QtWidgets.QLineEdit(self.verticalFrame)
        self.lineEdit_2.setMinimumSize(QtCore.QSize(300, 40))
        self.lineEdit_2.setMaximumSize(QtCore.QSize(300, 40))
        self.lineEdit_2.setStyleSheet("\n"
"border-radius:2px;\n"
"padding:2px;\n"
"content:'Password';\n"
"border:1px solid #262626;")
        self.lineEdit_2.setObjectName("lineEdit_2")
        self.verticalLayout.addWidget(self.lineEdit_2, 0, QtCore.Qt.AlignHCenter)
        self.toolButton_2 = QtWidgets.QToolButton(self.verticalFrame)
        self.toolButton_2.setMinimumSize(QtCore.QSize(300, 40))
        self.toolButton_2.setMaximumSize(QtCore.QSize(300, 40))
        self.toolButton_2.setStyleSheet("background:#ccc;\n"
"border-radius:2px;\n"
"\n"
"")
        self.toolButton_2.setObjectName("toolButton_2")
        self.verticalLayout.addWidget(self.toolButton_2, 0, QtCore.Qt.AlignHCenter)
        self.toolButton = QtWidgets.QToolButton(self.verticalFrame)
        self.toolButton.setMinimumSize(QtCore.QSize(300, 40))
        self.toolButton.setMaximumSize(QtCore.QSize(300, 40))
        self.toolButton.setStyleSheet("background-color:#f23041;\n"
"border-radius:5px;\n"
"color:#fff;\n"
"")

        self.toolButton.setObjectName("toolButton")
        self.verticalLayout.addWidget(self.toolButton, 0, QtCore.Qt.AlignHCenter)
        self.gridLayout.addWidget(self.verticalFrame, 0, 1, 1, 1)
        self.toolButton_2.clicked.connect(self.signin)
        self.toolButton.clicked.connect(self.signup)
        self.retranslateUi(Dialog)
        QtCore.QMetaObject.connectSlotsByName(Dialog)

    def retranslateUi(self, Dialog):
        _translate = QtCore.QCoreApplication.translate
        Dialog.setWindowTitle(_translate("Dialog", "Dialog"))
        self.toolButton_2.setText(_translate("Dialog", "SignIn"))


        self.toolButton.setText(_translate("Dialog", "SignUp"))

On the next step we will define the onclick controls for the signin and signup buttons , whose onclick function has already been declared

self.toolButton_2.clicked.connect(self.signin)
self.toolButton.clicked.connect(self.signup)

Step 9 --> The Onclick functions

def signup(self):
        email = self.lineEdit.text()
        password = self.lineEdit.text()
        user = auth.create_user_with_email_and_password(email, password)
        user = auth.refresh(user['refreshToken'])
        print('Sucessfully accounted in: {0}'.format(user['userId']))
        IsUser=user['userId']

    def signin(self):
        email = self.lineEdit.text()
        password = self.lineEdit.text()
        user = auth.sign_in_with_email_and_password(email, password) 
        user = auth.refresh(user['refreshToken'])
        print('Sucessfully logged in: {0}'.format(user['userId']))
        IsUser=user['userId']

Here we have declared the firebase login and signup functions with a message that would be printed on the console and you can see it if the task is successful.

On the basis of what task you perform
Step 10 --> On the last and final step lets start the window with an if statement

if __name__ == "__main__":
    app = QtWidgets.QApplication(sys.argv)

    MainWindow = QtWidgets.QMainWindow()
    ui = Ui_Dialog()

    ui.setupUi(MainWindow)
    MainWindow.show()
    sys.exit(app.exec_())

Run the app ...

The whole code is

from PyQt5 import QtCore, QtGui, QtWidgets
import sys
import pyrebase 
config = {
    "apiKey": "AIzaSyDZw2TKNMPLkFBI7qPzklTGbd8bYkIyfUc",
    "authDomain": "py-firebase-f97fc.firebaseapp.com",
    "databaseURL": "https://py-firebase-f97fc-default-rtdb.firebaseio.com",
    "projectId": "py-firebase-f97fc",
    "storageBucket": "py-firebase-f97fc.appspot.com",
    "messagingSenderId": "130186938120",
    "appId": "1:130186938120:web:d8b87ef2a01af62dbf4ebd",
    "measurementId": "G-9R811DMZEL",
    "serviceAccount":".\py-firebase-f97fc-firebase-adminsdk-7w4qw-52ae79b7e5.json"
    }

firebase = pyrebase.initialize_app(config)
try:
    IsUser=user['userId']
except:
       IsUser = None
auth = firebase.auth()
class Ui_Dialog(object):
# if IsUser == None :
    def setupUi(self, Dialog):
        Dialog.setObjectName("Python with Firebase")
        Dialog.resize(447, 621)
        self.gridLayout = QtWidgets.QGridLayout(Dialog)
        self.gridLayout.setObjectName("gridLayout")
        self.verticalFrame = QtWidgets.QFrame(Dialog)
        self.verticalFrame.setMinimumSize(QtCore.QSize(429, 300))
        self.verticalFrame.setObjectName("verticalFrame")
        self.verticalLayout = QtWidgets.QVBoxLayout(self.verticalFrame)
        self.verticalLayout.setObjectName("verticalLayout")

        self.lineEdit = QtWidgets.QLineEdit(self.verticalFrame)
        self.lineEdit.setMinimumSize(QtCore.QSize(300, 40))
        self.lineEdit.setMaximumSize(QtCore.QSize(500, 40))
        self.lineEdit.setStyleSheet("border-radius:2px;\n"
        "padding:2px;\n"
        "content:'Email';\n"
"border:1px solid #262626;")
        self.lineEdit.setObjectName("lineEdit")
        self.verticalLayout.addWidget(self.lineEdit, 0, QtCore.Qt.AlignHCenter)
        self.lineEdit_2 = QtWidgets.QLineEdit(self.verticalFrame)
        self.lineEdit_2.setMinimumSize(QtCore.QSize(300, 40))
        self.lineEdit_2.setMaximumSize(QtCore.QSize(300, 40))
        self.lineEdit_2.setStyleSheet("\n"
"border-radius:2px;\n"
"padding:2px;\n"
"content:'Password';\n"
"border:1px solid #262626;")
        self.lineEdit_2.setObjectName("lineEdit_2")
        self.verticalLayout.addWidget(self.lineEdit_2, 0, QtCore.Qt.AlignHCenter)
        self.toolButton_2 = QtWidgets.QToolButton(self.verticalFrame)
        self.toolButton_2.setMinimumSize(QtCore.QSize(300, 40))
        self.toolButton_2.setMaximumSize(QtCore.QSize(300, 40))
        self.toolButton_2.setStyleSheet("background:#ccc;\n"
"border-radius:2px;\n"
"\n"
"")
        self.toolButton_2.setObjectName("toolButton_2")
        self.verticalLayout.addWidget(self.toolButton_2, 0, QtCore.Qt.AlignHCenter)
        self.toolButton = QtWidgets.QToolButton(self.verticalFrame)
        self.toolButton.setMinimumSize(QtCore.QSize(300, 40))
        self.toolButton.setMaximumSize(QtCore.QSize(300, 40))
        self.toolButton.setStyleSheet("background-color:#f23041;\n"
"border-radius:5px;\n"
"color:#fff;\n"
"")

        self.toolButton.setObjectName("toolButton")
        self.verticalLayout.addWidget(self.toolButton, 0, QtCore.Qt.AlignHCenter)
        self.gridLayout.addWidget(self.verticalFrame, 0, 1, 1, 1)
        self.toolButton_2.clicked.connect(self.signin)
        self.toolButton.clicked.connect(self.signup)
        self.retranslateUi(Dialog)
        QtCore.QMetaObject.connectSlotsByName(Dialog)

    def retranslateUi(self, Dialog):
        _translate = QtCore.QCoreApplication.translate
        Dialog.setWindowTitle(_translate("Dialog", "Dialog"))
        self.toolButton_2.setText(_translate("Dialog", "SignIn"))


        self.toolButton.setText(_translate("Dialog", "SignUp"))

    def signup(self):
        email = self.lineEdit.text()
        password = self.lineEdit.text()
        user = auth.create_user_with_email_and_password(email, password)
        user = auth.refresh(user['refreshToken'])
        print('Sucessfully accounted in: {0}'.format(user['userId']))
        IsUser=user['userId']

    def signin(self):
        email = self.lineEdit.text()
        password = self.lineEdit.text()
        user = auth.sign_in_with_email_and_password(email, password)
        user = auth.refresh(user['refreshToken'])
        print('Sucessfully logged in: {0}'.format(user['userId']))
        IsUser=user['userId']



if __name__ == "__main__":
    app = QtWidgets.QApplication(sys.argv)

    MainWindow = QtWidgets.QMainWindow()
    ui = Ui_Dialog()

    ui.setupUi(MainWindow)
    MainWindow.show()
    sys.exit(app.exec_())

The whole code is also on my github repository -> https://github.com/Arkadeep-Nag/py-firebase-app/blob/main/main.py