DEV Community: Muhammet Tan

Book Review 1-Super Study Guide: Transformers & Large Language Models

Muhammet Tan — Mon, 24 Mar 2025 09:02:30 +0000

I guess no one among us is unaware of how much hype Large Language Models (LLMs) have generated nowadays. In a field where thousands of people are simultaneously discussing, developing, and conducting trainings, staying oblivious to the topic isn’t an option for individuals like myself who prefer not to be left behind. Especially if, like me, you’re a bit anxious, missing out on a development in the field of artificial intelligence can lead to dozens of questions swirling in your mind: “Have I fallen too far behind in the world of AI, or have my competitors surged ahead?” So, what’s the solution? Due to individual differences in learning styles and progress, I find it beneficial to at least keep up with the latest developments and learn using the most logical and reasonable method available to me: current books.

For me, reading a book feels like the opportunity to absorb years of accumulated knowledge from an author’s mind in just a few days. That, to me, translates back as decades of accumulated knowledge from various sources. At least, that’s my take. We mentioned books; why not videos? As I mentioned, this is entirely due to individual differences. While watching an educational video, I feel like I’m undergoing Chinese water torture, constantly fast-forwarding to get it over with, hoping it’ll cover whatever it’s supposed to. This only leads to me not understanding anything. For someone else, this process could be entirely different; as I said, at least for me, it’s like this.

Moreover, I unfortunately can’t take seriously the creators who go to great lengths to make the cover image of educational videos more attention-grabbing, all in the name of getting more likes, while simultaneously seeing videos that completely contradict their content, such as “RAG is dying,” “Transformer is dying?,” “PHP is dying.”

I’ve dragged on the introduction for too long. I’m a software developer, working as a full-stack developer in the ERP industry. Alongside my backend and frontend work, I research artificial intelligence as much as possible to add smart scenarios and solutions to the ERP industry. Additionally, I’m in the thesis phase of my master’s degree and aim to strengthen my academic side further by pursuing a Phd. Perhaps this academic curiosity is directing me towards books and articles rather than videos, but I’m not sure.

Without further ado, as I mentioned at the beginning of the topic, for those curious about how Large Language Models (LLMs) work and what goes on behind the scenes, there are hundreds of blog posts, educational documents, and videos available online. In this blog post of mine, I want to talk about the Super Study Guide: Transformers & Large Language Models book written by Afshine Amidi and Shervine Amidi, which I finished reading yesterday. Since I’ve just finished the book, I find it useful to relay its contents while they’re fresh in my mind, without delving into technical details.

First and foremost, when quickly flipping through the book’s pages (I’m talking about scrolling down the schrool:)), it was initially odd not to see any code examples. Instead of code, the book offers almost a visual feast, filled with clear and explanatory sentences supporting visuals, rather than lengthy texts or unnecessary details. Looking at the book’s sections, we see that it consists of 5 different parts. In the first part, it covers the fundamentals of deep learning such as performance evaluation metrics, bias, variance, optimizers. The second part extensively covers the concept of Embedding, discussing approaches like RNN, LSTM used before the transformer structure, and their respective disadvantages. The third part delves into the transformer architecture that forms the basic logic of LLMs in great detail, explaining not only the attention mechanism but also the encoder-decoder structure with wonderful visuals. Especially for those trying to understand the attention mechanism, it’s definitely beneficial to read this part a few times if the concepts of Query, Key, Value, and the mathematical operations creating a more efficient method than RNN and LSTM do not clearly form concrete things in their heads.

When examining the structure and narration of the book, I found it difficult to distinguish between the 4th and 5th sections in practice, as both discuss the structure and applications of LLMs. I must admit my ignorance here — I wasn’t aware that after the pretraining and fine-tuning phases, there was also a preference tuning phase. This section provides insights into how a model is further refined after fine-tuning through feedback labeled as correct or incorrect.

Additionally, this part covers PEFT (Parameter-Efficient Fine-Tuning) techniques such as LoRA, QLoRA, and Adapters, which allow us to train and fine-tune LLMs even on personal computers. Moreover, it discusses Retrieval-Augmented Generation (RAG), which enables models to gather information from external data sources rather than relying solely on their training data. The book also touches on practical topics frequently needed in real-world projects, such as model compression and reducing model size.

To summarize, this book thoroughly explains methods and technologies from the ground up, ensuring that readers don’t feel lost when grasping new concepts. As I mentioned, since it doesn’t delve too deeply into mathematical and theoretical details, I didn’t find it overwhelming. However, I do think it’s beneficial to take notes while reading and research certain concepts in more depth.

Additionally, it would have been great if the book had included a section on agent structures in LLMs and practical usage examples (I know, I’m asking for a lot!).

I highly recommend this book to anyone curious about artificial intelligence, especially those working with natural language processing. Of course, having some fundamental knowledge of deep learning wouldn’t hurt either.

In my next post, I will be reviewing Building LLMs for Production by Louis-François Bouchard and Louie Peters, which I have just started reading.

Thank you for taking the time to read!

Most used Pandas features — DataFrame [PART II]

Muhammet Tan — Tue, 21 Nov 2023 13:23:21 +0000

Hello, today I will talk about the pandas library. Pandas DataFrame can be initialize like this.

pandas.DataFrame(data, index, columns)

#data     -> it can be our list, dict,python obj etc.
#index    -> it is not compulsory, byb default start from 0
#columns  -> its optional parameter, we can specify the columns names

df=pd.DataFrame(["Paris", "Berlin", "Roma", "Ankara"])
print(df)

Output: 
        0
0   Paris
1  Berlin
2    Roma
3  Ankara

As you see in above code index and column title generated by default.Of course we can specify these values.Let’s learn how to create a Pandas Dataframe from dictionary with user defined column names and indexes.

import pandas as pd
import numpy as np

dict = {'capitals':["Paris", "Berlin", "Roma", "Ankara"],
        'population':[15, 12, 18, 9]}


row_label=["a","b","c","d"]

df = pd.DataFrame(dict,index=row_label)

print(df)

Output:
  capitals  population
a    Paris          15
b   Berlin          12
c     Roma          18
d   Ankara           9

We can also create dataframe from Series. Using concat() methot allows us to merge different series to make a new dataframe object.This proccess is very customizable via passing parameters.

import pandas as pd
import numpy as np

person = pd.Series(["Jack","Linda"])
fees = pd.Series([20000,25000])
department = pd.Series(['Acccountant','Manager'])


df=pd.concat([person,fees,department],axis=1,
             keys= ['Person', 'Salary', 'Department'])

Output:
  Person  Salary   Department
0   Jack   20000  Acccountant
1  Linda   25000      Manager

axis=1 to specify merge series as columns instead of rows

with key parameter we added column labels

Of course we could get the same result by doing this

person = pd.Series(["Jack","Linda"])
fees = pd.Series([20000,25000])
department = pd.Series(['Acccountant','Manager'])

df=pd.concat({"Person":person,"Salary":fees,"Department":department},axis=1)

We can create DataFrame using zip() function.Different list can be merged by this method like this.

person = ["Jack","Linda"]
fees = [20000,25000]
department = ['Acccountant','Manager']

tuples_list = list(zip(person, fees, department))
df = pd.DataFrame(tuples_list, columns = ['Person', 'Salary', 'Department'])

print(df)
Output:
  Person  Salary   Department
0   Jack   20000  Acccountant
1  Linda   25000      Manager

Most used Pandas features (At least I use often:) ) [PART I]

Muhammet Tan — Tue, 21 Nov 2023 11:54:43 +0000

We can create Pandas series from array,list,dict or a dataframe.

“In simple words Pandas Series is a one-dimensional labeled array that holds any data type (integers, strings, floating-point numbers, None, Python objects, etc.). The axis labels are collectively referred to as the index”

If you come from a object oriented programming language, you may be familiar with term of constructor.

#Pandas Series Constructor Syntax looks like this
Pandas.series(data,index,dtype,copy)`

#data: The data contains ndarray, list, constants.
#Index: The index must be unique and hashable. np.arrange(n) if no index is passed.
#dtype: dtype is also a data type.
#copy: It is used to copy the data. The data contains ndarray,

list, constants.
If you found above code messy, it is not important.Let’s start with basic implementations.

Creating a empty Pandas Series:

newserie= pd.Series() 
Output: Series([], dtype: float64)p

As you can see above if you create a empty pandas series, default datatype will be float and the index of the series starts from 0.

Basic Example Code:

# import pandas as pd
import pandas as pd

# import numpy as np
import numpy as np

# simple array
data = np.array(['g', 'e', 'e', 'k', 's'])

# providing an index
ser = pd.Series(data, index=[10, 11, 12, 13, 14])#we specify the indexes,
print(ser)

Output:
10    g
11    e
12    e
13    k
14    s
dtype: object

Creating a series from Numpy Array:

import pandas as pd 
import numpy as np
data = np.array(['python','php','java'])
series = pd.Series(data)
print (series)
Output:
0    python
1    php
2    java

Creating a series from lists (with indexes):

calories = pd.Series([320, 450, 140, 56], [“apple”, “banana”, “melon”, “bread”])

After creation we will see indexes in our first column, in the same way our
data will be in the second column.

Second example:

second_list=['C','T']
example =pd.Series(second_list)
output:
0  A 
1  T 
dtype: object

If we dont define index numbers, index numbers will be generated automatically.

Creating a serie from Dictionary

grades_dictionary={'A':100,'B':80,'C':70,'D':60}
grades=pd.Series(grades_dictionary)
print(grades)
Output:
A    100
B    80
C    70
D    60
dtype: object

Creating a Pandas series from List Comprehensions

seri = pd.Series(range(1,15,5), index=[i for i in ‘abc’])
print(seri)Output:
a     1
b     6
c    11
dtype: int64

first paramter of range is start value

second parameter of range is final value

last parameter of range is increase amount

from 1 to 15 => 1 (1)+ 5 (6) + 5 (11)...

Conditional Operations in Series

populations =pd.Series([1350, 1200, 350, 150], ["China", "India", "USA", "Russia"], name="Populations")
populations[populations> 500]
Output:
China       1350 
India       1200
Name: Populations, dtype: int64

We can also use logical operators like this.

populations[(populations > 200) & (populations < 1000)]
Output:
USA    350
Name: Populations, dtype: int64

Arithmetic operations in Pandas Series

data = pd.Series([1, 2, 3, 4], index=['a', 'b', 'c', 'd'])
data1 = pd.Series([5, 6, 7, 8], index=['d', 'a', 'f', 'g'])
data.add(data1)

Output :
a    7.0
b    NaN
c    NaN
d    9.0
f    NaN
g    NaN

As you can see above some results shown as Nan value.Because of that sequance of indexes are not same. For example in first serie (data), first index is ‘a’, but second index starts with index of ‘d’.

We can fill different indexes as we want. In order to do that we should add second parameter to add() method like this.

data.add(data1, fill_value=0)

Value of second parameter of add meethod is not mandatory.I use 0 value but you can enter value as you want 1,2,3, etc…

Datatype Conversions in Pandas

If you check out official pandas documentation, you will see this sentence: “Whether object dtypes should be converted to the best possible types.”

For example :

When you initialize a pandas series like this

serie1= pd.Series([9, 6, 3])
print(serie1)
Output:
0    9
1    6
2    3
dtype: int64 int64

Even though we didn’t define datatype of serie explicitly, output dataype has became int64. Well, if you are asked to specify the datatype or convert it other ones?

We can use astype() function to get rid of it.

For example:

serie1= pd.Series([9, 6, 3])
floatserie= serie1.astype(float)
Output:
0    9.0
1    6.0
2    3.0
dtype: float64 float64  #we can see that output datatype is float64

*Additional Information
We can easily convert Pandas Series to Python Lists with toList()

Like this

py_list= serie1.tolist()
Output: 
[9.0, 6.0, 3.0]

https://sparkbyexamples.com/python-pandas-tutorial-for-beginners/
https://pandas.pydata.org/docs/reference/api/pandas.Series.convert_dtypes.html

Colly Framework ile Go dilinde Web Scraping nasıl yapılır?

Muhammet Tan — Sun, 21 Nov 2021 16:32:22 +0000

Öncelikle go resmi dökümantasyonunda olduğu gibi bir proje oluşturuyoruz.

favori kod editörümüzü açıyoruz ve main.go dosyamızı oluşturuyoruz.İster VS Code terminalinde istersek işletim sisteminin terminalinde projenin olduğu dizinde
go get -u github.com/gocolly/colly/...
komutu ile colly framework yüklemesini başlatıyoruz.Kurulum esnasında sorun yaşarsanız,
http://go-colly.org/ ve https://github.com/gocolly/colly adreslerini inceleyebilirsiniz.

Bizim yapacağımız uygulamada tek bir amacımız var bu da TFF sitesinden Süper Lig puan durumunu çekmek.Bunu yapmak için temel düzeyde olsa html taglarını tanıyor olmanızı bekliyoruz.Eğer daha önce css kullanırken selector yazdıysanız bu iş size çocuk oyuncağı gelecektir.
Öyleyse kodlarımızı yazmaya başlayalım.

c := colly.NewCollector(
colly.AllowedDomains(),
)
komutu ile yeni bir Collector oluşturalım.Bu uygulamada bize bir adet collector yettiği için ekstra ekleme yapmayacağım fakat size kendi projenizde lazım olursa, herhangi bir struct tipinden örnek oluşturur gibi c2,c3,c4 şeklinde collector oluşturabilirsiniz.

Colly Framework kullanırken mutlaka Callback'ler ile karşılaşacaksınız.Android lifecycle konusuna benzettiğim bu yapıyı en iyi anlatan kısım ise yine kendi resmi dökümantasyonu

Callbackler konusuna şimdilik, yazıyı kısa ve anlaşılır tutmak için detaylı şekilde girmiyorum.Hevesimizi kaçırmadan hemen Tff resmi sitesinde puan durumu ve fikstür bilgisi yer alan sayfaya gidelim(Bu yazı yazılırken link: https://www.tff.org/default.aspx?pageID=198). Sayfayı açtıktan sonra geliştirici seçeneklerini açalım.

En sol üstte bulunan işarete tıklayıp sayfa üzerinde puan durumunun olduğu kısma tıklarsanız, ihtiyacımız olan alanın bir table yapısı içinde olduğu kolaylıkla anlaşılıyor.
Selector yazıp verileri alma işlemini table ın hemen üzerinde bulunan div i kullanıp yapacağız.

Burada div in id sini hemen kopyalayıp, örneğini oluşturduğumuz collector'ü kullanmaya başlıyoruz.
c.OnHTML Callback ' içine aşağıdaki kodları yazıyoruz.

Aşağıdaki kısma dikkat ediniz.
c.OnHTML("#ctl00_MPane_m_198_10561_ctnr_m_198_10561_Panel1>table>tbody>tr".... Normalde burayı tek bir td olsaydı tr>td>a şeklinde uzatabilirdim fakat, her tr nin içinde birçok td olduğu için bütün td leri teker teker gezmemiz gerekiyor.Bunun için selektörü "...>tr" de bitiririp, tr den sonra gelen td ler için ayrı bir forEach dönerek table da bulunan istatistikleri de yazmayı amaçladık.

Son olarak
c.Visit("https://www.tff.org/default.aspx?pageID=198")
kodunu ekleyerek uygulamamızın istediğimiz linki ziyaret edip verileri çekmesini bekliyoruz.
Çıktı :

Eğer isterseniz console a yazdırdığımız bu verileri .csv dosyasına da kaydedebiliriz. Bu kodları tam bütün halinde paylaşıyorum.
Esen kalın...
package main

import (
"encoding/csv"
"fmt"
"github.com/gocolly/colly"
"log"
"os"
)

func main() {

fName:="data.csv"
file,err:=os.Create(fName)
if err!=nil {
    log.Fatalf("Failed to c reate file: %q",err)
    return
}

defer file.Close()
writer:=csv.NewWriter(file)
defer writer.Flush()


// Instantiate default collector
c := colly.NewCollector(

    colly.AllowedDomains(),
)

// On every a element which has href attribute call callback
c.OnHTML("#ctl00_MPane_m_198_10561_ctnr_m_198_10561_Panel1>table>tbody>tr", func(e *colly.HTMLElement) {
    var liste_stats []string
    var takim string
    var statistics string
    e.ForEach("td", func(_ int, elem *colly.HTMLElement) {
        takim = elem.ChildText("a")
        statistics= elem.ChildText("span")
        liste_stats=append(liste_stats,takim )
        liste_stats=append(liste_stats, statistics)
    })
        fmt.Println(liste_stats)
        writer.Write(liste_stats)
        c.Visit(e.Request.AbsoluteURL(takim))
})


// Before making a request print "Visiting ..."
c.OnRequest(func(r *colly.Request) {
        fmt.Println("Visiting", r.URL.String())
})


c.Visit("https://www.tff.org/default.aspx?pageID=198")

}

GOLANG- MSSQL CRUD OPERATIONS

Muhammet Tan — Sat, 20 Nov 2021 13:55:47 +0000

In this tutorial, you will learn basic crud operations in golang.

Project structre looks like this.

Sql table design looks like this

After the creating pages and table, you need to download sql-golang framework with this github link
github.com/denisenkom/go-mssqldb

As you see we have three different go code pages.
in main.go , we call just one function(CheckDbConn()) to keep our aplication simple and clean.In golang main function entry point of the application we develop. Calling just one function is sufficient right now.

In db.go

We need to fill this area to establish connection between our application and sql database.If you get connection error, you had better check sql username, password,sql port number.

Full code
db.go

package main

import (
"database/sql"
f "fmt"
"log"

_ "github.com/denisenkom/go-mssqldb"

)

var (
Server = "localhost"
Port = 1433
User = "sa"
Password = 1453
Db = "Products"
)

func CheckDbConn() {

var err error

ConnString := f.Sprintf("server=%s;user id=%s;password=%d;port=%d;database=%s;",
    Server, User, Password, Port, Db)

conn, err := sql.Open("sqlserver", ConnString)
if err != nil {
    log.Fatal("Open connection failed:", err.Error())
}
f.Printf("Connected!\n")
defer conn.Close()
option := 0
f.Println("0.GET \n1.INSERT \n2.UPDATE \n3.DELETE")
f.Scanln(&option)
switch option {
case 0:
    GetProducts(conn)
case 1:
     result,_:= CreateProduct(conn)

    f.Println(result)
case 2:
    UpdateProduct(conn)
case 3:
    DeleteProduct(conn)
default:
    f.Println("Invalid operation request")
}

}

db.handler.go

package main

import (
"database/sql"
f "fmt"
"strings"
)

func GetProducts(db *sql.DB) (int, error) {

getProduct_sql := "select * from Products"

rows, err := db.Query(getProduct_sql)
if err != nil {
    f.Println("Error reading records: ", err.Error())
}
defer rows.Close()

count := 0
for rows.Next() {
    var name string
    var price float64
    var id int
    err := rows.Scan(&id, &name, &price)
    if err != nil {
        f.Println("Error reading rows: " + err.Error())
        return -1, err
    }
    f.Printf("ID: %d, Name: %s, Price: %f\n", id, name, price)
    count++
}
return count, nil

}

func CreateProduct(db *sql.DB)(int64,error){

var name string
f.Print("Please enter your product name: ")
f.Scanln(&name)

var price float64
f.Print("Please enter your product's price: ")
f.Scanln(&price)

insertProduct_sql := f.Sprintf("INSERT INTO Products (name,price) VALUES ('%s' , %f ); select ID = convert(bigint, SCOPE_IDENTITY()) ",strings.Title(strings.ToLower(name)),price)


rows,err:=db.Query(insertProduct_sql)
if err !=nil{
    f.Println("Error occured while inserting a record", err.Error())
    return -1,err
}


defer rows.Close()
var lastInsertId1 int64
for rows.Next() {
    rows.Scan(&lastInsertId1)

}


return lastInsertId1,err

}

func InfoMsG(db *sql.DB,id int64) {
infoQuery:=f.Sprintf("Select name from Products where id=%d",id)
rows,err := db.Query(infoQuery)
if err !=nil{
f.Println("Error occured while giving info: ", err.Error())
}
defer rows.Close()

for rows.Next(){
    var name string
    var id =id
    err:=rows.Scan(&name)
    if err !=nil {
        f.Println("Error reading end process product id with, " , id, err)
    }else{
        f.Printf(name + " product has been created " )
    }



}

}

func UpdateProduct(db *sql.DB) {
f.Print("Please enter product id which you want to change: ")
var id int
f.Scanln(&id)

f.Print("Please enter new product name ")
var name string
f.Scanln(&name)

f.Print("Please enter new product'price ")
var price float64
f.Scanln(&price)

update_query := f.Sprintf("UPDATE Products set name='%s', price=%f where id=%d",name,price,id)

_, err := db.Exec(update_query)
if err != nil {
    f.Println("Failed: " + err.Error())
}
f.Println("Product informations updated successfully")

}

func DeleteProduct(db *sql.DB){
f.Print("Please enter product id which you want to delete: ")
var id int
f.Scanln(&id)

delete_query:=f.Sprintf("DELETE FROM Products where id=%d",id)
_, err := db.Exec(delete_query)
if err != nil {
    f.Println("Failed: " + err.Error())
}
f.Println("Product deleted successfully")

}

main.go
package main

func main() {
CheckDbConn()
}