Sets in Python - Learn How to Use Sets in Python, you will learn the fundamentals of Sets in Python. Learn how to work effectively with Python's set data type. We will explore: What sets are and why they are relevant for your projects, How to create a set, How to check if an element is in a set, The difference between sets and frozensets, How to operate with sets (in this part we will dive into the basics of set theory), How to add and remove elements from sets and how to clear them

In this article, you will learn the fundamentals of Sets in Python. This is a very powerful built-in data type that you can use in your Python projects.

**We will explore:**

- What sets are and why they are relevant for your projects.
- How to create a set.
- How to check if an element is in a set.
- The difference between sets and frozensets.
- How to operate with sets (in this part we will dive into the basics of set theory).
- How to add and remove elements from sets and how to clear them.

**Let's begin! π
**

Let me start by telling you why would you want to use sets in your projects. In mathematics, a set is a collection of distinct objects. In Python, what makes them so special is the fact that **they have no duplicate elements**, so they can be used to remove duplicate elements from lists and tuples efficiently.

According to the Python Documentation:

Python also includes a data type for

sets. A set is an unordered collection with no duplicate elements. Basic uses include membership testing and eliminating duplicate entries.

**π‘ Important:** The elements of a set must be immutable (they cannot be changed). Immutable data types include strings, tuples, and numbers such as integers and floats.

To create a set, we start by writing a pair of curly brackets `{}`

and within those curly brackets, we include the elements of the set separated by a comma and a space.

π‘ **Tip:** Notice that this syntax is different from Python dictionaries because we are not creating key-value pairs, we are simply including individual elements within curly brackets `{}`

.

Alternatively, we can use the set() function to create a set (see below).

To do this, we would pass an iterable (for example, a list, string, or tuple) and this iterable would be converted to a set, removing any duplicate elements.

This is an example in IDLE:

```
# Set
>>> {1, 2, 3, 4}
{1, 2, 3, 4}
# From a list
>>> set([1, 2, 3, 4])
{1, 2, 3, 4}
# From a tuple
>>> set((1, 2, 3, 4))
{1, 2, 3, 4}
```

**π‘ Tip:** To create an empty set, you must use the set() function because using an empty set of curly brackets, like this `{}`

, will automatically create an empty **dictionary**, not an empty set.

```
# Creates a dictionary, not a set.
>>> type({})
<class 'dict'>
# This is a set
>>> type(set())
<class 'set'>
```

πΉ Duplicate Elements are Removed
If the iterable that you pass as the argument to `set()`

has duplicate elements, they are removed to create the set.

For example, notice how duplicate elements are removed when we pass this list:

```
>>> a = [1, 2, 2, 2, 2, 3, 4, 1, 4]
>>> set(a)
{1, 2, 3, 4}
```

and notice how duplicate characters are removed when we pass this string:

```
>>> a = "hhheeelllooo"
>>> set(a)
{'e', 'l', 'o', 'h'}
```

πΈ Length
To find the length of a set, you can use the built-in function len():

```
>>> a = {1, 2, 3, 4}
>>> b = set(a)
>>> len(b)
4
```

In mathematics, the number of elements of a set is called the "**cardinality**" of the set.

You can test if an element is in a set with the `in`

operator:

This in an example:

```
>>> a = "hhheeelllooo"
>>> b = set(a)
>>> b
{'e', 'l', 'o', 'h'}
# Test if the characters 'e' and 'a' are in set b
>>> 'e' in b
True
>>> 'a' in b
False
```

πΈ Sets vs. Frozensets
Sets are mutable, which means that they can be modified after they have been defined.

According to the Python Documentation:

The

`set`

type ismutableβ the contents can be changed using methods like`add()`

and`remove()`

. Since it is mutable, it has no hash value and cannot be used as either a dictionary key or as an element of another set.

Since they cannot contain values of mutable data types, if we try to create a set that contains sets as elements (nested sets), we will see this error:

```
TypeError: unhashable type: 'set'
```

This is an example in IDLE. Notice how the elements that we are trying to include are sets:

```
>>> a = {{1, 2, 3}, {1, 2, 4}}
Traceback (most recent call last):
File "<pyshell#23>", line 1, in <module>
a = {{1, 2, 3}, {1, 2, 4}}
TypeError: unhashable type: 'set'
```

To solve this problem, we have another type of set called frozensets.

They are **immutable**, sothey cannot be changed and we can use them to create nested sets.

According to the Python Documentation:

The

`frozenset`

type is immutable and hashable β its contents cannot be altered after it is created; it can therefore be used as a dictionary key or as an element of another set.

To create a frozenset, we use:

π‘ **Tip:** You can create an empty frozenset with `frozenset()`

.

This is an example of a set that contains two frozensets:

```
>>> a = {frozenset([1, 2, 3]), frozenset([1, 2, 4])}
>>> a
{frozenset({1, 2, 3}), frozenset({1, 2, 4})}
```

Notice that we don't get any errors and the set is created successfully.

πΉ Introduction to Set TheoryBefore diving into set operations, we need to explore a little bit of set theory and Venn diagrams. We will dive into each set operation with its corresponding equivalent in Python code. Let's begin.

You can think of a subset as a "smaller portion" of a set. That is how I like to think about it. If you take some of the elements of a set and make a new set with those elements, the new set is a subset of the original set.

It's as if you had a bag full of rubber balls of different colors. If you make a set with all the rubber balls in the bag, and then take some of those rubber balls and make a new set with them, the new set is a subset of the original set.

Let me illustrate this graphically. If we have a set A with the elements 1, 2, 3, 4:

```
>>> a = {1, 2, 3, 4}
```

We can "take" or "select" some elements of a and make a new set called B. Let's say that we chose to include the elements 1 and 2 in set B:

```
>>> a = {1, 2, 3, 4}
>>> b = {1, 2}
```

Every element of B is in A. Therefore, B is a subset of A.

This can be represented graphically like this, where the new set B is illustrated in yellow:

**π‘ Note:** In set theory, it is a convention to use uppercase letters to denote sets. This is why I will use them to refer to the sets (A and B), but I will use lowercase letter in Python (a and b).

We can check if B is a subset of A with the method .issubset():

```
>>> a = {1, 2, 3, 4}
>>> b = {1, 2}
>>> b.issubset(a)
True
```

As you can see, B is a subset of A because the value returned is `True`

.

But the opposite is not true since not all the element of A are in B:

```
>>> a.issubset(b)
False
```

Let's see something very interesting:

```
>>> a = {1, 2, 3, 4}
>>> b = {1, 2, 3, 4}
>>> a.issubset(b)
True
>>> b.issubset(a)
True
```

If two sets are equal, one is a subset of the other and vice versa because all the elements of A are in B and all elements of B are in A. This can be illustrated like this:

We can achieve the same functionality of the `.issubset()`

method with the `<=`

comparison operator:

```
>>> a = {1, 2, 3, 4}
>>> b = {1, 2, 3, 4}
>>> a <= b
True
```

This operator returns `True`

if the left operand is a subset of the right operand, even when the two sets are equal (when they have the same elements).

But what happens if we want to check if a set is a **proper subset** of another? A proper subset is a subset that is not equal to the set (does not have all the same elements).

This would be a graphical example of a proper subset. B does not have all the elements of A:

To check this, we can use the `<`

comparison operator:

```
# B is not a proper subset of A because B is equal to A
>>> a = {1, 2, 3, 4}
>>> b = {1, 2, 3, 4}
>>> b < a
False
# B is a proper subset of A because B is not equal to A
>>> a = {1, 2, 3, 4}
>>> b = {1, 2}
>>> b < a
True
```

**If B is a subset of A, then A is a superset of B**. A superset is the set that contains all the elements of the subset.

This can be illustrated like this (see below), where A is a superset of B:

We can test if a set is a superset of another with the .issuperset() method:

```
>>> a = {1, 2, 3, 4}
>>> b = {1, 2}
>>> a.issuperset(b)
True
```

We can also use the operators `>`

and `>=`

. They work exactly like `<`

and `<=`

, but now they determine if the left operand is a **superset** of the right operand:

```
>>> a = {1, 2, 3, 4}
>>> b = {1, 2}
>>> a > b
True
>>> a >= b
True
```

Two sets are disjoint if they have no elements in common. For example, here we have two disjoint sets:

We can check if two sets are disjoint with the .isdisjoint() method:

```
# Elements in common: 3, 1
>>> a = {3, 6, 1}
>>> b = {2, 8, 3, 1}
>>> a.isdisjoint(b)
False
# Elements in common: None
>>> a = {3, 1, 4}
>>> b = {8, 9, 0}
>>> a.isdisjoint(b)
True
```

πΈ Set Operations
We can operate on sets to create new sets, following the rules of set theory. Let's explore these operations.

This is the first operation that we will analyze. It creates a new set that contains all the elements of the two sets (without repetition).

This is an example:

```
>>> a = {3, 1, 7, 4}
>>> b = {2, 8, 3, 1}
>>> a | b
{1, 2, 3, 4, 7, 8}
```

π‘ **Tip:** We can assign this new set to a variable, like this:

```
>>> a = {3, 1, 7, 4}
>>> b = {2, 8, 3, 1}
>>> c = a | b
>>> c
{1, 2, 3, 4, 7, 8}
```

In a diagram, these sets could be represented like this (see below). This is called a Venn diagram, and it is used to illustrate the relationships between sets and the result of set operations.

We can easily extend this operation to work with more than two sets:

```
>>> a = {3, 1, 7, 4}
>>> b = {2, 8, 3, 1}
>>> c = {1, 0, 4, 6}
>>> d = {8, 2, 6, 3}
# Union of these four sets
>>> a | b | c | d
{0, 1, 2, 3, 4, 6, 7, 8}
```

π‘ **Tip:** If the union contains repeated elements, only one is included in the final set to eliminate repetition.

The intersection between two sets creates another set that contains all the elements that are **in** **both A and B**.

This is an example:

```
>>> a = {3, 6, 1}
>>> b = {2, 8, 3, 1}
>>> a & b
{1, 3}
```

The Venn diagram for the intersection operation would be like this (see below), because only the elements that are **in both A and B** are included in the resulting set:

We can easily extend this operation to work with more than two sets:

```
>>> a = {3, 1, 7, 4, 5}
>>> b = {2, 8, 3, 1, 5}
>>> c = {1, 0, 4, 6, 5}
>>> d = {8, 2, 6, 3, 5}
# Only 5 is in a, b, c, and d.
>>> a & b & c & d
{5}
```

The difference between set A and set B is another set that contains all the **elements of set A that are not in set B**.

This is an example:

```
>>> a = {3, 6, 1}
>>> b = {2, 8, 3, 1}
>>> a - b
{6}
```

The Venn diagram for this difference would be like this (see below), because only the elements of A that are not in B are included in the resulting set:

π‘ **Tip:** Notice how we remove the elements of A that are also in B (in the intersection).

We can easily extend this to work with more than two sets:

```
>>> a = {3, 1, 7, 4, 5}
>>> b = {2, 8, 3, 1, 5}
>>> c = {1, 0, 4, 6, 5}
# Only 7 is in A but not in B and not in C
>>> a - b - c
{7}
```

The symmetric difference between two sets A and B is another set that contains **all the elements that are in either A or B, but not both**. We basically remove the elements from the intersection.

```
>>> a = {3, 6, 1}
>>> b = {2, 8, 3, 1}
>>> a ^ b
{2, 6, 8}
```

The Venn diagram for the symmetric difference would be like this (see below), because only the elements that are in either A or B, but not both, are included in the resulting set:

We can easily extend this to work with more than two sets:

```
>>> a = {3, 1, 7, 4, 5}
>>> b = {2, 8, 3, 1, 5}
>>> c = {1, 0, 4, 6, 5}
>>> d = {8, 2, 6, 3, 5}
>>> a ^ b ^ c ^ d
{0, 1, 3, 7}
```

If you want to update set A immediately after performing these operations, you can simply add an equal sign after the operator. For example:

```
>>> a = {1, 2, 3, 4}
>>> b = {1, 2}
# Notice the &=
>>> a &= b
>>> a
{1, 2}
```

We are assigning the set that results from `a & b`

to set `a`

in just one line. You can do the same with the other operators: `^=`

, `|=`

, and `-=`

.

**π‘ Tip:** This is very similar to the syntax that we use with variables (for example: `a += 5`

) but now we are working with sets.

Sets include helpful built-in methods to help us perform common and essential functionality such as adding elements, deleting elements, and clearing the set.

To add elements to a set, we use the .add() method, passing the element as the only argument.

```
>>> a = {1, 2, 3, 4}
>>> a.add(7)
>>> a
{1, 2, 3, 4, 7}
```

There are three ways to delete an element from a set: `.remove(<elem>)`

,`.discard(<elem>)`

, and `.pop()`

. They have key differences that we will explore.

The first two methods (.remove() and .discard()) work exactly the same when the element is in the set. The new set is returned:

```
>>> a = {1, 2, 3, 4}
>>> a.remove(3)
>>> a
{1, 2, 4}
>>> a = {1, 2, 3, 4}
>>> a.discard(3)
>>> a
{1, 2, 4}
```

The key difference between these two methods is that if we use the .remove() method, we run the risk of trying to remove an element that doesn't exist in the set and this will raise a `KeyError`

:

```
>>> a = {1, 2, 3, 4}
>>> a.remove(5)
Traceback (most recent call last):
File "<pyshell#102>", line 1, in <module>
a.remove(5)
KeyError: 5
```

We will never have that problem with .discard() since it doesn't raise an exception if the element is not found. This method will simply leave the set intact, as you can see in this example:

```
>>> a = {1, 2, 3, 4}
>>> a.discard(5)
>>> a
{1, 2, 3, 4}
```

The third method (.pop()) will remove and return an arbitrary element from the set and it will raise a `KeyError`

if the set is empty.

```
>>> a = {1, 2, 3, 4}
>>> a.pop()
1
>>> a.pop()
2
>>> a.pop()
3
>>> a
{4}
>>> a.pop()
4
>>> a
set()
>>> a.pop()
Traceback (most recent call last):
File "<pyshell#119>", line 1, in <module>
a.pop()
KeyError: 'pop from an empty set'
```

You can use the `.clear()`

method if you need to delete all the elements from a set. For example:

```
>>> a = {1, 2, 3, 4}
>>> a.clear()
>>> a
set()
>>> len(a)
0
```

In Summary
- Sets are unordered built-in data types that don't have any repeated elements, so they allow us to eliminate repeated elements from lists and tuples.
- They are mutable and they can only contain immutable elements.
- We can check if a set is a subset or superset of another set.
- Frozenset is an immutable type of set that allows us to create nested sets.
- We can operate on sets with: union (
`|`

), intersection (`&`

), difference (`-`

), and symmetric difference (`^`

). - We can add elements to a set, delete them, and clear the set completely using built-in methods.

Python tutorial for beginners - Learn Python for Machine Learning and Web Development. Can Python be used for machine learning? Python is widely considered as the preferred language for teaching and learning ML (Machine Learning). Can I use Python for web development? Python can be used to build server-side web applications. Why Python is suitable for machine learning? How Python is used in AI? What language is best for machine learning?

Python tutorial for beginners - Learn Python for Machine Learning and Web DevelopmentTABLE OF CONTENT

- 00:00:00 Introduction
- 00:01:49 Installing Python 3
- 00:06:10 Your First Python Program
- 00:08:11 How Python Code Gets Executed
- 00:11:24 How Long It Takes To Learn Python
- 00:13:03 Variables
- 00:18:21 Receiving Input
- 00:22:16 Python Cheat Sheet
- 00:22:46 Type Conversion
- 00:29:31 Strings
- 00:37:36 Formatted Strings
- 00:40:50 String Methods
- 00:48:33 Arithmetic Operations
- 00:51:33 Operator Precedence
- 00:55:04 Math Functions
- 00:58:17 If Statements
- 01:06:32 Logical Operators
- 01:11:25 Comparison Operators
- 01:16:17 Weight Converter Program
- 01:20:43 While Loops
- 01:24:07 Building a Guessing Game
- 01:30:51 Building the Car Game
- 01:41:48 For Loops
- 01:47:46 Nested Loops
- 01:55:50 Lists
- 02:01:45 2D Lists
- 02:05:11 My Complete Python Course
- 02:06:00 List Methods
- 02:13:25 Tuples
- 02:15:34 Unpacking
- 02:18:21 Dictionaries
- 02:26:21 Emoji Converter
- 02:30:31 Functions
- 02:35:21 Parameters
- 02:39:24 Keyword Arguments
- 02:44:45 Return Statement
- 02:48:55 Creating a Reusable Function
- 02:53:42 Exceptions
- 02:59:14 Comments
- 03:01:46 Classes
- 03:07:46 Constructors
- 03:14:41 Inheritance
- 03:19:33 Modules
- 03:30:12 Packages
- 03:36:22 Generating Random Values
- 03:44:37 Working with Directories
- 03:50:47 Pypi and Pip
- 03:55:34 Project 1: Automation with Python
- 04:10:22 Project 2: Machine Learning with Python
- 04:58:37 Project 3: Building a Website with Django

**Thanks for reading** β€

If you liked this post, share it with all of your programming buddies!

Follow us on **Facebook** | **Twitter**

β Complete Python Bootcamp: Go from zero to hero in Python 3

β Machine Learning A-Zβ’: Hands-On Python & R In Data Science

β Python and Django Full Stack Web Developer Bootcamp

β Complete Python Masterclass

β Python Programming Tutorial | Full Python Course for Beginners 2019 π

β Top 10 Python Frameworks for Web Development In 2019

β Python for Financial Analysis and Algorithmic Trading

β Building A Concurrent Web Scraper With Python and Selenium

In this "Python Tutorial: Data Science vs. Web Development" to provide a comparison on the two completely different purposes of using Python language and help understand that it is not necessary to know Python as a web programming language for doing data science in Python.

Python programming has various frameworks and features to expand in web application development, graphical user interfaces, data analysis, data visualization, etc. Python programming language might not be an ideal choice for web application development, but is extensively used by many organizations for evaluating large datasets, for data visualization, for running data analysis or prototyping. Python programming language is gaining traction amongst users for data science whilst being outmoded as a web programming language. The idea of this blog post is to provide a comparison on the two completely different purposes of using Python language and help understand that it is not necessary to know Python as a web programming language for doing data science in Python.

Organizations of all sizes and industries β from the top financial institutions to the smallest big data start-ups are using Python programming language to run their business.

Python language is among the popular data science programming languages not only with the top big data companies but also with the tech start up crowd. Python language ranks among the top 10 programming languages to learn in 2019.

Python language comes in the former category and is finding increased adoption in numerical computations, machine learning and several data science applications. Python language can do anything, excluding performance dependent and low level stuff. The best bet to use Python programming language is for data analysis and statistical computations. Learning Python programming for web development requires programmers to master various web frameworks like Django that can help the build websites whereas learning Python for data science requires data scientists to learn the usage of regular expressions, get working with the scientific libraries and master the data visualization concepts. With completely different purposes, programmers or professionals who are not knowledgeable about web programming concepts with Python language can easily go ahead and pursue data science in Python programming language without any difficulty.

Python is a 23-year-old powerful expressive dynamic programming language where a programmer can write the code once and execute it without using a separate compiler for the purpose. Python in web development supports various programming paradigms such as structured programming, functional programming and object oriented programming. Python language code can be easily embedded into various existing web application that require a programming interface. However, Python language is a preeminent choice for academic, research and scientific applications which need faster execution and precise mathematical calculations.

Python web programming requires programmers to learn about the various python web development frameworks, which can be intimidating because the documentation available for the python web development frameworks might be somewhat difficult to understand. However, it is undeniable that to develop a dynamic website or a web application using Python language, learning a web framework is essential.

There are several Python web application frameworks available for free like-

**Django**

Django is the python web development framework for perfectionists with deadlines. Python web development with django is best suited for developing database driven web applications with attractive features like automatic admin interface and a templating system. For web development projects that donβt require extensive features, Django may be an overkill because of its confusing file system and strict directory structure. Some companies that are using python web development with django are The New York Times, Instagram, and Pinterest.

**Flask**

It is a simple and lightweight solution for beginners who want to get started with developing single-page web applications. This framework does not support for validation, data abstraction layer and many other components that various other frameworks include. It is not a full stack framework and is used only in the development of small websites.

**CherryPy**

It emphasizes on Pythonic conventions so that programmers can build web applications just the way they would do it using object oriented Python programming. CherryPy is the base template for other popular full stack frameworks like TurboBears and Web2py.

There are so many other web frameworks like Pyramid, Bottle, and Pylons etc. but regardless of the fact, whichever web framework a python programmer uses, the challenge is that he/she needs to pay close attention to detailing on the tutorials and documentation.

Python programming language probably is an impractical choice for being chosen as a web programming language β

Python for web development requires non-standard and expensive hosting particularly when programmers use popular python web frameworks for building websites. With PHP language being so expedient for web programming, most of the users are not interested in investing in Python programming language for web development.

Python language for web development is not a commonly demanded skill unlike demand for other web development languages like PHP, Java or Ruby on Rails. Python for Data science is gaining traction and is the most sought after skill companies are looking for in data scientists, with its increased adoption in machine learning and various other data science applications.

Python for web development has come a long way but it does not have a steep learning curve as compared to other web programming languages like PHP.

Why Python for Data Science is the best fit?

Python programming is the core technology that powers big data, finance, statistics and number crunching with English like syntax. The recent growth of the rich Python data science ecosystem with multiple packages for Machine learning, natural language processing, data visualization, data exploration, data analysis and data mining is resulting in Pythonification of the data science community. Today, Python data science language has all the nuts and bolts for cleaning, transforming, processing and crunching big data. Python is the most in-demand skill for data scientist job role. A data scientist with python programming skills in New York earns an average salary of $180,000

Data Scientists like to work in a programming environment that can quickly prototype by helping them jot down their ideas and models easily. They like to get their stuff done by analysing huge datasets to draw conclusions. Python programming is the most versatile and capable all-rounder for data science applications as it helps data scientists do all this productively by taking optimal minimal time for coding, debugging, executing and getting the results.

The real value of a great enterprise data scientist is to use various data visualizations that can help communicate the data patterns and predictions to various stakeholders of the business effectively, otherwise it is just a zero-sum game. Python has almost every aspect of scientific computing with high computational intensity which makes it a supreme choice for programming across different data science applications, as programmers can do all the development and analysis in one language. Python for data science links between various units of a business and provides a direct medium for data sharing and processing language.

- Python has a unified design philosophy that focuses on ease of use, readability and easy learning curve for data science.
- Python has high scalability and is much faster when compared to other languages like Stata, Matlab.
- There are more and more data visualization libraries and cool application programming interfaces being added for inclusion of graphics to depict the results of data analysis.
- Python has a large community with good number of data science or data analytics libraries like Sci-Kit learn, NumPy, Pandas, and Statsmodels, SciPy etc. which have rich functionality and have been tested extensively. Data analysis libraries in Python language are growing over time.

Data analysis and Python programming language go hand in hand. If you have taken a decision to learn Data Science in Python language, then the next question in your mind would be βWhat are the best data science in Python libraries that do most of the data analysis task? Here are top data analysis libraries in Python used by enterprise data scientists across the world-

**NumPy**

It is the foundation base for the higher level tools built in Python programming language. This library cannot be used for high level data analysis but in-depth understanding of array oriented computing in NumPy helps data scientists use the Pandas library effectively.

**SciPy**

SciPy is used for technical and scientific computing with various modules for integration, special functions, image processing, interpolation, linear algebra, optimizations, ODE solvers and various other tasks. This library is used to work with NumPy arrays with various efficient numerical routines.

**Pandas**

This is the best library for doing data munging as this library makes it easier to handle missing data, supports automatic data alignment, supports working with differently indexed data gathered from multiple data sources.

**SciKit**

This is a popular machine learning library with various regression, classification and clustering algorithms with support for gradient boosting, vector machines, naΓ―ve Bayes, and logistic regression. This library is designed to interoperate with NumPy and SciPy.

**Matplotlib**

It is a 2D plotting library with interactive features for zooming and panning for publication quality figures in different hard copy formats and in interactive environments across various platforms.

Complete hands-on Machine Learning tutorial with Data Science, Tensorflow, Artificial Intelligence, and Neural Networks. Introducing Tensorflow, Using Tensorflow, Introducing Keras, Using Keras, Convolutional Neural Networks (CNNs), Recurrent Neural Networks (RNNs), Learning Deep Learning, Machine Learning with Neural Networks, Deep Learning Tutorial with Python

Machine Learning, Data Science and Deep Learning with PythonExplore the full course on Udemy (special discount included in the link): http://learnstartup.net/p/BkS5nEmZg

In less than 3 hours, you can understand the theory behind modern artificial intelligence, and apply it with several hands-on examples. This is machine learning on steroids! Find out why everyoneβs so excited about it and how it really works β and what modern AI can and cannot really do.

In this course, we will cover:

β’ Deep Learning Pre-requistes (gradient descent, autodiff, softmax)

β’ The History of Artificial Neural Networks

β’ Deep Learning in the Tensorflow Playground

β’ Deep Learning Details

β’ Introducing Tensorflow

β’ Using Tensorflow

β’ Introducing Keras

β’ Using Keras to Predict Political Parties

β’ Convolutional Neural Networks (CNNs)

β’ Using CNNs for Handwriting Recognition

β’ Recurrent Neural Networks (RNNs)

β’ Using a RNN for Sentiment Analysis

β’ The Ethics of Deep Learning

β’ Learning More about Deep Learning

At the end, you will have a final challenge to create your own deep learning / machine learning system to predict whether real mammogram results are benign or malignant, using your own artificial neural network you have learned to code from scratch with Python.

Separate the reality of modern AI from the hype β by learning about deep learning, well, deeply. You will need some familiarity with Python and linear algebra to follow along, but if you have that experience, you will find that neural networks are not as complicated as they sound. And how they actually work is quite elegant!

This is hands-on tutorial with real code you can download, study, and run yourself.