Learn machine learning with scikit-learn, covering supervised learning, clustering, regression, SVMs, autoencoders, and ensemble methods through practical Python projects.

ml.tar.gz

Playground

Playground-SPA

Complexity CH-1

regulizer CH-1

regulizer CH-1-S

regulizer ch1_v2

complexity ch1_v2

code_widget

ST_kernel_trick-LIVE

python

pytorch

ST_Autoencoders

code_widget_torchsummary

code_widget_tqdm

SPA_tqdm

AE_multiple

SPA_server

Implementation of NN

c1l3

Implementation of NN-copy

This course focuses on core concepts, algorithms, and machine learning techniques. It explores the fundamentals, implements algorithms from scratch, and compares the results with scikit-learn, the Python machine learning library. This course contains examples, theoretical knowledge, and codes for various ML algorithms.

You’ll start by learning the essentials of machine learning and its applications. Then, you’ll learn about supervised learning, clustering, and constructing a bag of visual words project, followed by generalized linear regression, support vector machines, logistic regression, ensemble learning, and principal component analysis. You’ll also learn about autoencoders and variational autoencoders and end with three exciting projects.

By the end, you’ll have a solid understanding of machine learning and its algorithms, hands-on experience implementing such algorithms and applying them to different problems, and an understanding of how each algorithm works with the provided examples.

Fundamentals of Machine Learning: A Pythonic Introduction

# What is CVXPY?
[**CVXPY**](https://www.cvxpy.org/index.html) is a Python-embedded modeling language for convex optimization problems. It allows users to write and solve convex optimization problems simply and intuitively.



# Why CVXPY?
Several properties of CVXPY make it practical while working on convex optimization. We list here the most important ones:

- It can verify the convexity of an optimization problem, even if the problem is not represented in a standard form.

- It can transform a convex optimization problem into one of the more suitable standard forms and make decisions about the appropriate algorithm to solve it. This, in some instances, can be challenging even for experts in this domain.

> **Note:** CVXPY is a modeling language for convex optimization problems. It's not a solver.

# Installation
To use `cvxpy`, we first need to install it. The easiest way to install `cvxpy` is via `pip`, the Python package installer.

```
pip install cvxpy
```
Once `cvxpy` is installed, we can use it in our Python scripts.

# Problem formulation
The first step in solving a convex optimization problem using `cvxpy` is to define the problem. Consider a constraint optimization problem as follows:

```
minimize f(x)
subject to g(x) <= h
```

Here, `f(x)` is the objective function, `x` is the optimization variable, and `g(x)<=h` is a set of inequality constraints. For a concrete example, let the objective be $f(x,y)=x^2+y^2$ and a single constraint be $g(x,y)\ge 1$, where $g(x,y)=x+y$. To solve this problem using `cvxpy`, we follow the following steps:
1. Import the package.
```
import cvxpy as cp
```

2. Define optimisation variables `x` and `y`.

```
x = cp.Variable()
y = cp.Variable()
```

3. Define the objective.

```
objective = cp.Minimize(x**2 + y**2)
```

4. Define the constraints using a Python list.
```
constraints = [x + y >= 1]
```

5. Create a `Problem` object to represent the optimisation problem.

```
prob = cp.Problem(objective, constraints)
```

6. Solve the problem.

```
prob.solve()
```

7. Print the solution.

```
print("Optimal value of the objecive: ", prob.value)
print("Optimal value x: ", x.value)
print("Optimal value y: ", y.value)
```

Learn how to use CVXPY for optimization problems with installation and problem formulation.

Introduction to CVXPY

Course Overview

Supervised Learning

Detect Cyber Intrusion Using Machine Learning

Clustering

Project: Bag of Visual Words

Generalized Linear Regression

Face Recognition Using Kernel Linear Discriminant

Support Vector Machine

Logistic Regression

Ensemble Learning

Early Stage Diabetes Prediction Using Ensemble Learning

Decoding Dimensions: PCA and Autoencoders

Image Reconstruction Using PCA

Image Colorization using Autoencoders

Colorful Face Generation with VAEs

Appendix

Wrapping Up

Introduction to CVXPY

What is CVXPY?

Why CVXPY?