These 9 lectures from Stanford are a pure goldmine for anyone wanting to learn and understand LLMs in depth

Lecture 1 - Transformer: https://lnkd.in/dGnQW39t

Lecture 2 - Transformer-Based Models & Tricks: https://lnkd.in/dT_VEpVH

Lecture 3 - Tranformers & Large Language Models: https://lnkd.in/dwjjpjaP

Lecture 4 - LLM Training: https://lnkd.in/dSi_xCEN

Lecture 5 - LLM tuning: https://lnkd.in/dUK5djpB

Lecture 6 - LLM Reasoning: https://lnkd.in/dAGQTNAM

Lecture 7 - Agentic LLMs: https://lnkd.in/dWD4j7vm

Lecture 8 - LLM Evaluation: https://lnkd.in/ddxE5zvb

Lecture 9 - Recap & Current Trends: https://lnkd.in/dGsTd8jN

Start understanding #LLMs in depth from the experts. Go through each step-by-step video.

https://news.1rj.ru/str/DataAnalyticsX 🔗

👍 A fresh deep learning course from MIT is now available publicly

A full-fledged educational course has been published on the university's website: 24 lectures, practical tasks, homework assignments, and a collection of materials for self-study.

The program includes modern neural network architectures, generative models, transformers, inference, and other key topics.

A great opportunity to study deep learning based on the structure of a top university, free of charge and without simplifications — let's learn here.
https://ocw.mit.edu/courses/6-7960-deep-learning-fall-2024/resources/lecture-videos/

tags: #python #deeplearning

➡ @codeprogrammer

🔖 An excellent resource for learning about neural networks

We're sharing a cool resource for learning about neural networks, offering clear, step-by-step instruction with dynamic visualizations and easy-to-understand explanations.

In addition, you'll find many other useful materials on machine learning on the site.

Find and use it — https://mlu-explain.github.io/neural-networks/

tags: #AI #ML #PYTHON

➡ @CODEPROGRAMMER

Data scientists are in high demand right now: there's just too much data to analyze.

In this course, Tatev and Vae teach #Python for #DataScience.

You'll be doing projects and exploring EDA, A/B testing, BI, and more.

https://news.1rj.ru/str/Python53 🌟

📱Cheat sheet on string methods in Python

1. Makes the first letter capitalized

.capitalize()

2. Lowers or raises the case of a string
.lower()
.upper()

3. Centers the string with symbols around it: 'Python' → 'Python'

.center(10, '*') 

4. Counts the occurrences of a specific character

.count('0')

5. Finds the positions of specified characters

.find()
.index()

6. Searches for a desired object and replaces it

.replace()

7. Splits the string, removing the split point from it
.split()

8. Checks what the string consists of
.isalnum()
.isnumeric()
.islower()
.isupper()

tags: #useful

➡ https://news.1rj.ru/str/CodeProgrammer

Stop using if obj == None, use if obj is None

In Python, when you write:

obj == None

you're not directly checking if obj is the value None. Instead, you're asking if the object is equal to None.

Yes, in many cases, the result will be the same as for the code:

obj is None

But the behavior of these two variants is different, and this difference is important.

When you use:

obj == None

Python calls the __eq__ method on the object. That is, the object itself decides what it means to be "equal to None". And this method can be overridden.

If obj is an instance of a class in which __eq__ is implemented so that when compared with None, it returns True (even if the object is not actually None), then obj == None may mistakenly give True.

Example:

class Weird:
    def __eq__(self, other):
        return True  # Always asserts that it's equal

obj = Weird()

print(obj == None)  # True
print(obj is None)  # False

Here, it can be seen that obj == None returns True due to the custom behaeqf the __eq__ operator in the class.

Therefore, when using obj == None, the result is not always predictable.

On the other hand, when you write:

obj is None

you're using the is operator, which cannot be overridden. This means that the result will always be the same and predictable.

The is operator checks the identity of objects, that is, whether two references point to the same object. Since None is a singleton (the only instance), obj is None is the correct and most efficient way to perform such a check.

❤️ Therefore, it is always recommended, and this is best practice, to use obj is None instead of obj == None for predictability and efficiency.

👉 https://news.1rj.ru/str/DataScienceQ