I am working on the file "2 - Neural Network/Project/Your_first_neural_network.ipynb".
The first task is:
Unit tests
Run these unit tests to check the correctness of your network implementation. This will help you be sure your network was implemented correctly befor you starting trying to train it. These tests must all be successful to pass the project.
Can you write Python code for it?

import unittest

inputs = np.array([[0.5, -0.2, 0.1]])
targets = np.array([[0.4]])
test_w_i_h = np.array([[0.1, -0.2],
                       [0.4, 0.5],
                       [-0.3, 0.2]])
test_w_h_o = np.array([[0.3],
                       [-0.1]])

class TestMethods(unittest.TestCase):

    ##########
    # Unit tests for data loading
    ##########

    def test_data_path(self):
        # Test that file path to dataset has been unaltered
        self.assertTrue(data_path.lower() == 'bike-sharing-dataset/hour.csv')

    def test_data_loaded(self):
        # Test that data frame loaded
        self.assertTrue(isinstance(rides, pd.DataFrame))

    ##########
    # Unit tests for network functionality
    ##########

    def test_activation(self):
        network = NeuralNetwork(3, 2, 1, 0.5)
        # Test that the activation function is a sigmoid
        self.assertTrue(np.all(network.activation_function(0.5) == 1/(1+np.exp(-0.5))))

    def test_train(self):
        # Test that weights are updated correctly on training
        network = NeuralNetwork(3, 2, 1, 0.5)
        network.weights_input_to_hidden = test_w_i_h.copy()
        network.weights_hidden_to_output = test_w_h_o.copy()

        network.train(inputs, targets)
#         print("w_h_o")
#         print(network.weights_hidden_to_output)
        self.assertTrue(np.allclose(network.weights_hidden_to_output,
                                    np.array([[ 0.37275328],
                                              [-0.03172939]])))
        self.assertTrue(np.allclose(network.weights_input_to_hidden,
                                    np.array([[ 0.10562014, -0.20185996],
                                              [0.39775194, 0.50074398],
                                              [-0.29887597, 0.19962801]])))

    def test_run(self):
        # Test correctness of run method
        network = NeuralNetwork(3, 2, 1, 0.5)
        network.weights_input_to_hidden = test_w_i_h.copy()
       ...


I am working on the file "2 - Neural Network/Project/Your_first_neural_network.ipynb".
The first task is:
We'll split the data into two sets, one for training and one for validating as the network is being trained. Since this is time series data, we'll train on historical data, then try to predict on future data (the validation set).
Can you write Python code for it?

# Hold out the last 60 days or so of the remaining data as a validation set
train_features, train_targets = features[:-60*24], targets[:-60*24]
val_features, val_targets = features[-60*24:], targets[-60*24:]


I am working on the file "2 - Strings.ipynb".
The first task is:
A unicode string is a different type of object from regular "str" string, but the unicode string is compatible (they share the common superclass "basestring"), and the various libraries such as regular expressions work correctly if passed a unicode string instead of a regular string.
To convert a unicode string to bytes with an encoding such as 'utf-8', call the ustring.encode('utf-8') method on the unicode string. Going the other direction, the unicode(s, encoding) function converts encoded plain bytes to a unicode string:`
Can you write Python code for it?

s = ustring.encode('utf-8')
s

t = unicode(s, 'utf-8')             ## Convert bytes back to a unicode string
t == ustring


I am working on the file "2 - Strings.ipynb".
The first task is:
For numbers, the standard operators, +, /, * work in the usual way. There is no ++ operator, but +=, -=, etc. work. If you want integer division, it is most correct to use 2 slashes -- e.g. 6 // 5 is 1 (previous to python 3000, a single / does int division with ints anyway, but moving forward // is the preferred way to indicate that you want int division.)
The "print" operator prints out one or more python items followed by a newline (leave a trailing comma at the end of the items to inhibit the newline). A "raw" string literal is prefixed by an 'r' and passes all the chars through without special treatment of backslashes, so r'x\nx' evaluates to the length-4 string 'x\nx'. A 'u' prefix allows you to write a unicode string literal (Python has lots of other unicode support features -- see the docs below).
Can you write Python code for it?

raw = r'this\t\n and that'
print raw

print """It was the best of times.
  It was the worst of times."""


I am working on the file "2 - Strings.ipynb".
The first task is:
I find that omitting the ":" is my most common syntax mistake when typing in the above sort of code, probably since that's an additional thing to type vs. my C++/Java habits. Also, don't put the boolean test in parens -- that's a C/Java habit. If the code is short, you can put the code on the same line after ":", (this applies to functions, loops, etc. also), although some people feel it's more readable to space things out on separate lines.
Can you write Python code for it?

def cop_stop(speed, mood):
    if speed >= 120:
        print 'License and registration please'
        if mood == 'terrible' or speed >= 150: print 'You have the right to remain silent.'
        elif mood == 'bad' or speed >= 130: print "I'm going to have to write you a ticket."
    else:
        print "Let's try to keep it under 120 ok?"


I am working on the file "2 - Strings.ipynb".
The first task is:
Omitting both always gives us a copy of the whole thing (this is the pythonic way to copy a sequence like a string or list)
Can you write Python code for it?


I am working on the file "2 - Strings.ipynb".
The first task is:
String Methods
Here are some of the most common string methods. A method is like a function, but it runs "on" an object. If the variable s is a string, then the code s.lower() runs the lower() method on that string object and returns the result (this idea of a method running on an object is one of the basic ideas that make up Object Oriented Programming, OOP). Here are some of the most common string methods:

s.lower(), s.upper() -- returns the lowercase or uppercase version of the string
s.strip() -- returns a string with whitespace removed from the start and end
s.isalpha()/s.isdigit()/s.isspace()... -- tests if all the string chars are in the various character classes
s.startswith('other'), s.endswith('other') -- tests if the string starts or ends with the given other string
s.find('other') -- searches for the given other string (not a regular expression) within s, and returns the first index where it begins or -1 if not found
s.replace('old', 'new') -- returns a string where all occurrences of 'old' have been replaced by 'new'
s.split('delim') -- returns a list of substrings separated by the given delimiter. The delimiter is not a regular expression, it's just text. 'aaa,bbb,ccc'.split(',') -> ['aaa', 'bbb', 'ccc']. As a convenient special case s.split() (with no arguments) splits on all whitespace chars.
s.join(list) -- opposite of split(), joins the elements in the given list together using the string as the delimiter. e.g. '---'.join(['aaa', 'bbb', 'ccc']) -> aaa---bbb---ccc

A google search for "python str" should lead you to the official python.org string methods which lists all the str methods.
Python does not have a separate character type. Instead an expression like s[8] returns a string-length-1 containing the character. With that string-length-1, the operators ==, <=, ... all work as you would expect, so mostly you don't need to know that Python does not have a separate scalar "char" type.
String Slices
The "slice" syntax is a handy way to refer to sub-parts of sequences -- typically strings and...
Can you write Python code for it?


I am working on the file "2 - Strings.ipynb".
The first task is:
The above line is kind of long -- suppose you want to break it into separate lines. You cannot just split the line after the '%' as you might in other languages, since by default Python treats each line as a separate statement (on the plus side, this is why we don't need to type semi-colons on each line). To fix this, enclose the whole expression in an outer set of parenthesis -- then the expression is allowed to span multiple lines. This code-across-lines technique works with the various grouping constructs detailed below: ( ), [ ], { }.
Can you write Python code for it?

("%d little pigs come out or I'll %s and %s and %s" %
    (3, 'huff', 'puff', 'blow down'))


I am working on the file "2 - Strings.ipynb".
The first task is:
The built-in print does not always work with unicode strings. You can encode() first to print in utf-8 or whatever. In the file-reading section, there's an example that shows how to open a text file with some encoding and read out unicode strings. Note that unicode handling is one area where Python 3 is significantly cleaned up vs. Python 2.x behavior described here.
If Statement
Python does not use { } to enclose blocks of code for if/loops/function etc.. Instead, Python uses the colon (:) and indentation/whitespace to group statements. The boolean test for an if does not need to be in parenthesis (big difference from C++/Java), and it can have elif and else clauses (mnemonic: the word "elif" is the same length as the word "else").
Any value can be used as an if-test. The "zero" values all count as false: None, 0, empty string, empty list, empty dictionary. There is also a Boolean type with two values: True and False (converted to an int, these are 1 and 0). Python has the usual comparison operations: ==, !=, <, <=, >, >=. Unlike Java and C, == is overloaded to work correctly with strings. The boolean operators are the spelled out words and, or, not (Python does not use the C-style && || !). Here's what the code might look like for a policeman pulling over a speeder -- notice how each block of then/else statements starts with a : and the statements are grouped by their indentation:
Can you write Python code for it?

def cop_stop(speed, mood):
    if speed >= 120:
        print 'License and registration please'
        if mood == 'terrible' or speed >= 150:
            print 'You have the right to remain silent.'
        elif mood == 'bad' or speed >= 130:
            print "I'm going to have to write you a ticket."
    else:
        print "Let's try to keep it under 120 ok?"

cop_stop(125, 'terrible')


I am working on the file "2 - Strings.ipynb".
The first task is:
The standard zero-based index numbers give easy access to chars near the start of the string. As an alternative, Python uses negative numbers to give easy access to the chars at the end of the string: s[-1] is the last char 'o', s[-2] is 'l' the next-to-last char, and so on. Negative index numbers count back from the end of the string:
Can you write Python code for it?


I am working on the file "2 - Strings.ipynb".
The first task is:
i18n Strings (Unicode)
Regular Python strings are not unicode, they are just plain bytes. To create a unicode string, use the 'u' prefix on the string literal:
Can you write Python code for it?

ustring = u'A unicode \u018e string \xf1'
ustring


I am working on the file "2 - Traffic Sign Classifier/Traffic_Sign_Classifier.ipynb".
The first task is:
2.2 Visualizing the dataset
Loading a random image in color along with its index
Can you write Python code for it?

### Data exploration visualization code goes here.
### Feel free to use as many code cells as needed.

import matplotlib.pyplot as plt
# Visualizations will be shown in the notebook.
%matplotlib inline
import random
import numpy as np

randomIndex = random.randint(0, len(X_train))
image = X_train[randomIndex].squeeze()
#plt.figure(figsize=(2,2))
plt.imshow(image)

print(image.shape)
print(y_train[randomIndex])


I am working on the file "2 - Traffic Sign Classifier/Traffic_Sign_Classifier.ipynb".
The first task is:
Analyze Performance
Output Top 5 Softmax Probabilities For Each Image Found on the Web
Can you write Python code for it?

##Applying softmax to logits
with tf.Session() as sess:
    softmax_probs = sess.run(tf.nn.softmax(new_images_classification))
print(softmax_probs)

### Print out the top five softmax probabilities for the predictions on the German traffic sign images found on the web.
## Finding top_k on the softmax outputs
with tf.Session() as sess:
    #predictions = sess.run(tf.nn.top_k(tf.constant(new_images_classification), k=5))
    predictions = sess.run(tf.nn.top_k(tf.constant(softmax_probs), k=5))
for i in range(len(predictions[0])):
    print('The image', i, 'is about', predictions[0][i], 'chance to be the sign with index:', predictions[1][i])


I am working on the file "2 - Traffic Sign Classifier/Traffic_Sign_Classifier.ipynb".
The first task is:
Evaluating Performance of the Model
Can you write Python code for it?

with tf.Session() as sess:
    saver.restore(sess, tf.train.latest_checkpoint('.'))

    training_accuracy = evaluate(X_train, y_train)
    test_accuracy = evaluate(X_test, y_test)
    validation_accuracy = evaluate(X_valid, y_valid)

    print("Training Accuracy = {:.3f}".format(training_accuracy))
    print("Test Accuracy = {:.3f}".format(test_accuracy))
    print("Validation Accuracy = {:.3f}".format(validation_accuracy))


I am working on the file "2 - Traffic Sign Classifier/Traffic_Sign_Classifier.ipynb".
The first task is:
Predict the Sign Type for Each Image
Can you write Python code for it?

signNames = np.genfromtxt("signnames.csv", dtype=None, delimiter=",", names=True)
#signName = [name[1].decode('utf-8') for name in signNames]
for i in range(0, len(signNames)):
    print(signNames[i])

# Preprocess new_images by normalizing
new_images_data = normalize_grayscale(new_images_data)
print(new_images_data.shape)

# Testing the model on the new images
probability_to_keep = tf.placeholder(tf.float32)
with tf.Session() as sess:
    saver.restore(sess, training_save_file)
    new_images_classification = sess.run(logits, feed_dict={x: new_images_data, probability_to_keep : 1.0})
print(new_images_classification)


I am working on the file "2 - Traffic Sign Classifier/Traffic_Sign_Classifier.ipynb".
The first task is:
Setup TensorFlow
Can you write Python code for it?

import tensorflow as tf

EPOCHS = 100
BATCH_SIZE = 150
keep_prob = 0.9 #dropout

from tensorflow.contrib.layers import flatten

def LeNet(x):
    # Arguments used for tf.truncated_normal, randomly defines variables for the weights and biases for each layer
    mu = 0
    sigma = 0.1

    # Layer 1: Convolutional. Input = 32x32x3. Output = 28x28x6.
    conv1_W = tf.Variable(tf.truncated_normal(shape=(5, 5, 3, 6), mean = mu, stddev = sigma))
    conv1_b = tf.Variable(tf.zeros(6))
    conv1   = tf.nn.conv2d(x, conv1_W, strides=[1, 1, 1, 1], padding='VALID') + conv1_b
    print("ConvNet 1: ", conv1)

    # Activation.
    conv1 = tf.nn.relu(conv1)

    # Pooling. Input = 28x28x6. Output = 14x14x6.
    conv1 = tf.nn.max_pool(conv1, ksize=[1, 2, 2, 1], strides=[1, 2, 2, 1], padding='VALID')
    conv1 = tf.nn.dropout(conv1, keep_prob)

    # Layer 2: Convolutional. Output = 10x10x16.
    conv2_W = tf.Variable(tf.truncated_normal(shape=(5, 5, 6, 16), mean = mu, stddev = sigma))
    conv2_b = tf.Variable(tf.zeros(16))
    conv2   = tf.nn.conv2d(conv1, conv2_W, strides=[1, 1, 1, 1], padding='VALID') + conv2_b
    print("ConvNet 2: ", conv2)

    # Activation.
    conv2 = tf.nn.relu(conv2)

    # Pooling. Input = 10x10x16. Output = 5x5x16.
    conv2 = tf.nn.max_pool(conv2, ksize=[1, 2, 2, 1], strides=[1, 2, 2, 1], padding='VALID')
    conv2 = tf.nn.dropout(conv2, keep_prob)

    # Flatten. Input = 5x5x16. Output = 400.
    fc0   = flatten(conv2)
    print("Fully Connected 0: ", fc0)

    # Layer 3: Fully Connected. Input = 400. Output = 120.
    fc1_W = tf.Variable(tf.truncated_normal(shape=(400, 120), mean = mu, stddev = sigma))
    fc1_b = tf.Variable(tf.zeros(120))
    fc1   = tf.matmul(fc0, fc1_W) + fc1_b
    fc1 = tf.nn.dropout(fc1, keep_prob) #keep_prob should be set to one for validation accuracy

    # Activation.
    fc1    = tf.nn.relu(fc1)
    print("Fully Connected 1: ", fc1)

    # Layer 4: Fully Connected. Input = 120. Output = 84.
    fc2_W  =...


I am working on the file "2 - Traffic Sign Classifier/Traffic_Sign_Classifier.ipynb".
The first task is:
Step 3: Test a Model on New Images
To give yourself more insight into how your model is working, download at least five pictures of German traffic signs from the web and use your model to predict the traffic sign type.
You may find signnames.csv useful as it contains mappings from the class id (integer) to the actual sign name.
Load and Output the Images
Can you write Python code for it?

import cv2
import os
import matplotlib.image as mpimage

directory = "german-traffic-signs/"
new_images = os.listdir(directory)
# Retrieve only images with valid image extensions
image_extenstions = ['jpg', 'bmp', 'png', 'gif']
new_images = [imgname for imgname in os.listdir(directory)
              if any(imgname.endswith(ext) for ext in image_extenstions)]

# Show the images, add to a list to process for classifying
new_images_data = []

for image in new_images:
    imagePath = directory + image
    image = mpimage.imread(imagePath)

    print(image.shape)
    # Remove alpha channel from image so it only has 3 RGB channels
    # Length of grayscale images is 2 i.e., len(image.shape) == 2
    if len(image.shape) > 2 and image.shape[2] == 4:
    #convert the image from RGBA2RGB
        image = cv2.cvtColor(image, cv2.COLOR_BGRA2BGR)
    new_images_data.append(image)
    plt.imshow(image)
    plt.colorbar()
    plt.show()

# Convert the new_images data to match the LeNet training dataset image shape (32 x 32 x 3)
#print(new_images_data)
new_images_data = np.array(new_images_data)
print(new_images_data.shape)


I am working on the file "2 - Traffic Sign Classifier/Traffic_Sign_Classifier.ipynb".
The first task is:
The pickled data is a dictionary with 4 key/value pairs:

'features' is a 4D array containing raw pixel data of the traffic sign images, (num examples, width, height, channels).
'labels' is a 1D array containing the label/class id of the traffic sign. The file signnames.csv contains id -> name mappings for each id.
'sizes' is a list containing tuples, (width, height) representing the original width and height the image.
'coords' is a list containing tuples, (x1, y1, x2, y2) representing coordinates of a bounding box around the sign in the image. THESE COORDINATES ASSUME THE ORIGINAL IMAGE. THE PICKLED DATA CONTAINS RESIZED VERSIONS (32 by 32) OF THESE IMAGES

Step 2: Dataset Exploration by determining Summary & Vizualization
2.1 Summarizing the Dataset
Can you write Python code for it?

def getDatasetInfo():
    # Get the number of training examples
    n_train = len(X_train)

    # Get the number of validation examples
    n_validation = len(X_valid)

    # Get the number of testing examples.
    n_test = len(X_test)

    # Get the shape of an traffic sign image?
    image_shape = X_train[1].shape

    # Get the number of unique classes/labels there are in the dataset.
    n_classes = len(set(y_train))

    print("Summary statistics of the traffic signs dataset")
    print()
    print("Number of training examples =", n_train)
    print("Number of testing examples =", n_test)
    print("Number of validation examples =", n_validation)
    print("Image data shape =", image_shape)
    print("Number of classes =", n_classes)

getDatasetInfo()


I am working on the file "2 - Traffic Sign Classifier/Traffic_Sign_Classifier.ipynb".
The first task is:
Train the Model
Run the training data through the training pipeline to train the model. Before each epoch, the training set is shuffled.
After each epoch, the loss is measured and the accuracy of the validation set determined.
The model is the saved for future runs.
Can you write Python code for it?

training_save_file = './lenet.ckpt'

with tf.Session() as sess:
    sess.run(tf.global_variables_initializer())
    num_examples = len(X_train)

    print("Training...")
    print()
    for i in range(EPOCHS):
        X_train, y_train = shuffle(X_train, y_train)
        for offset in range(0, num_examples, BATCH_SIZE):
            end = offset + BATCH_SIZE
            batch_x, batch_y = X_train[offset:end], y_train[offset:end]
            sess.run(training_operation, feed_dict={x: batch_x, y: batch_y})

        #training_accuracy = evaluate(X_train, y_train)
        #testing_accuracy = evaluate(X_test, y_test)
        validation_accuracy = evaluate(X_valid, y_valid)
        print("EPOCH {} ...".format(i+1))
        #print("Training Accuracy = {:.3f}".format(training_accuracy))
        #print("Test Accuracy = {:.3f}".format(test_accuracy))
        print("Validation Accuracy = {:.3f}".format(validation_accuracy))
        print()

    saver.save(sess, training_save_file)
    print("Model saved")


I am working on the file "2 - Working with Django.ipynb".
The first task is:
Alternatively, capture the output, and render it as SVG:
Can you write Python code for it?

dot = !manage.py graph_models shows 2>/dev/null
Source(dot.n)


I am working on the file "2 - Working with Django.ipynb".
The first task is:
Answering questions
How often do we play gigs?
Can you write Python code for it?

gigs = Gig.objects.published().past()
gigs.count()


I am working on the file "2 - Working with Django.ipynb".
The first task is:
How many gigs have we played each year?
Can you write Python code for it?

for date in gigs.dates('date', 'year'):
    gig_count = gigs.filter(date__year=date.year).count()
    print('{}: {}'.format(date.year, gig_count))


I am working on the file "2 - Working with Django.ipynb".
The first task is:
View the output of the graph_models command from Django Extensions:
Can you write Python code for it?

from graphviz import Source
from IPython.display import Image

!manage.py graph_models music news shows -o models.png  2>/dev/null
Image('models.png')


I am working on the file "2 Dimensional Array Manipulations and Equalization.ipynb".
The first task is:
This matches our constructed histogram so we can proceed to create a new histogram and construct the equalized one
Can you write Python code for it?

newimg = np.empty(z.shape)
## This should be the same exact dimensions as the original array
print newimg
print z.shape

## set x_length to the first number, y_length to the second
x_length = z.shape[0]
y_length = z.shape[1]

print x_length, y_length

for i in range(x_length):
    for j in range(y_length):
        newimg[i][j] = norm_cdf[ z[i][j] ]

print newimg


I am working on the file "2 Dimensional Array Manipulations and Equalization.ipynb".
The first task is:
This probably didn't work because of the tiny size of the array, let's try something more established
Can you write Python code for it?

img = [
    [52, 55, 61,  66,  70,  61, 64, 73],
    [63, 59, 55,  90, 109,  85, 69, 72],
    [62, 59, 68, 113, 144, 104, 66, 73],
    [63, 58, 71, 122, 154, 106, 70, 69],
    [67, 61, 68, 104, 126,  88, 68, 70],
    [79, 65, 60,  70,  77,  68, 58, 75],
    [85, 71, 64,  59,  55,  61, 65, 83],
    [87, 79, 69,  68,  65,  76, 78, 94]
]

img = np.asarray(img)
print img

print " "

print img[0]
print img[1]

print " "

imgflat = img.reshape(-1)
print imgflat
print imgflat.sum()

print " "
fig = plt.hist(imgflat, bins='auto')
plt.title('Histogram')
plt.show()

print " "

imgnorm = imgflat*1.0/sum(imgflat)
print imgnorm

fig = plt.hist(imgnorm, bins = 'auto')
plt.title('Normalized Histogram')
plt.show

import math

## Reminder of Z's values
print img

# Number of pixels
pixels = len(img) * len(img[0])
print "The number of pixels is {}".format(pixels)
## The output should be 4 since there are 4 numbers in this array

##Flatten method doesn't work because of tuple conversion later on
'''# Now we flatten Z
zz = z.reshape(-1)'''

# Initialize histogram and CDF
hist = {}
cdf = {}
norm_cdf = {}
## The range value should be be adjusted to the bin number

BINS = 255

for i in range(BINS):
    hist[i] = 0
    cdf[i] = 0
    norm_cdf[i] = 0

# Create histogram

for row in img:
    for val in row:
        hist[val] += 1

'''
for val in zz:
    hist[val] += 1
'''

# Create cdf
for i in range(BINS):
    for j in range(i+1):
        cdf[i] += hist[j]
    norm_cdf[i] = int(math.floor(float(cdf[i]-1)/63*BINS))

print "The histogram values are {}".format(hist)
print "The cdf values are {}".format(cdf)
print "The normalized cdf values are {}".format(norm_cdf)

newimg = np.empty(img.shape)
## This should be the same exact dimensions as the original array
print newimg
print img.shape

## set x_length to the first number, y_length to the second
x_length = img.shape[0]
y_length = img.shape[1]

print x_length, y_length

for i in range(x_length):
    for j in range(y_length):
        newimg[i][j] = norm_cdf[ img[i][j]...


I am working on the file "2 Supervised learning/Homework/1 linear regression and main data analysis libraries/peer_review_linreg_height_weight.ipynb".
The first task is:
[10]. Постройте 3D-график зависимости функции ошибки, посчитанной в п.6 от параметров $w_0$ и $w_1$. Подпишите ось $x$ меткой «Intercept», ось $y$ – меткой «Slope», a ось $z$ – меткой «Error».
Can you write Python code for it?

fig = plt.figure()
ax = fig.gca(projection='3d') # get current axis

# Создаем массивы NumPy с координатами точек по осям X и У.
# Используем метод meshgrid, при котором по векторам координат
# создается матрица координат. Задаем нужную функцию Z(x, y).
X = np.arange(0., 100., 1)
Y = np.arange(-5., 5., 0.5)
X, Y = np.meshgrid(X, Y)
squaredErrorVect = np.vectorize(squaredError)
Z = np.array( squaredErrorVect(X.ravel(), Y.ravel()) )
Z.shape = X.shape

# Наконец, используем метод *plot_surface* объекта
# типа Axes3DSubplot. Также подписываем оси.
surf = ax.plot_surface(X, Y, Z)
ax.set_xlabel('Intercept')
ax.set_ylabel('Slope')
ax.set_zlabel('Error')
plt.show()


I am working on the file "2 Supervised learning/Homework/1 linear regression and main data analysis libraries/peer_review_linreg_height_weight.ipynb".
The first task is:
[11]. С помощью метода minimize из scipy.optimize найдите минимум функции, определенной в п. 6, для значений параметра $w_0$ в диапазоне [-100,100] и $w_1$ - в диапазоне [-5, 5]. Начальная точка – ($w_0$, $w_1$) = (0, 0). Используйте метод оптимизации L-BFGS-B (аргумент method метода minimize). Проведите на графике из п. 5 Задания 1 прямую, соответствующую найденным оптимальным значениям параметров $w_0$ и $w_1$. Подпишите оси и график.
Can you write Python code for it?

from scipy.optimize import minimize
squaredErrorOneArg = lambda w: squaredError(w[0], w[1])
bnds = ((-100., 100.), (-5., 5.))
x0 = (0., 0.)
optww1Res = minimize(squaredErrorOneArg, x0, bounds=bnds, method='L-BFGS-B')
print optww1Res
optw0 = optww1Res.x[0]
optw1 = optww1Res.x[1]
print 'Optimal ( w0, w1 ) value: (', round(optw0, 3), ',', round(optw1, 3), ')'

#значения линейной аппроксимации для оптимального значения w1
yLinesOpt = np.array( lineFunc(xLines, optw0, optw1) )

#построение графиков
dataPlot = data.plot(x='Weight', y='Height', kind='scatter', title=u'Зависимость роста от веса', label=u'Data points')
dataPlot.set(xlabel=u'Вес', ylabel=u'Рост')

plt.plot(xLines, yLinesOpt, c='red', label=u'Optimal line')

plt.legend()
plt.axis( [75, 175, 60, 75] )
plt.title(u'Зависимость роста от веса')
plt.xlabel(u'Вес')
plt.ylabel(u'Рост')

plt.show()


I am working on the file "2 Supervised learning/Homework/1 linear regression and main data analysis libraries/peer_review_linreg_height_weight.ipynb".
The first task is:
[3]. Постройте картинку, на которой будут отображены попарные зависимости признаков , 'Height', 'Weight' и 'BMI' друг от друга. Используйте метод pairplot библиотеки Seaborn.
Can you write Python code for it?


I am working on the file "2 Supervised learning/Homework/1 linear regression and main data analysis libraries/peer_review_linreg_height_weight.ipynb".
The first task is:
[5]. Постройте scatter plot зависимости роста от веса, используя метод plot для Pandas DataFrame с аргументом kind='scatter'. Подпишите картинку.
Can you write Python code for it?

dataPlot = data.plot(x='Weight', y='Height', kind='scatter', title=u'Зависимость роста от веса')
dataPlot.set(xlabel=u'Вес', ylabel=u'Рост')
plt.show()


I am working on the file "2 Supervised learning/Homework/1 linear regression and main data analysis libraries/peer_review_linreg_height_weight.ipynb".
The first task is:
Итак, мы решаем задачу: как через облако точек, соответсвующих наблюдениям в нашем наборе данных, в пространстве признаков "Рост" и "Вес" провести прямую линию так, чтобы минимизировать функционал из п. 6. Для начала давайте отобразим хоть какие-то прямые и убедимся, что они плохо передают зависимость роста от веса.
[7]. Проведите на графике из п. 5 Задания 1 две прямые, соответствующие значениям параметров ($w_0, w_1) = (60, 0.05)$ и ($w_0, w_1) = (50, 0.16)$. Используйте метод plot из matplotlib.pyplot, а также метод linspace библиотеки NumPy. Подпишите оси и график.
Can you write Python code for it?

#lambda-функция прямой
lineFunc = lambda x, w0, w1: w0 + w1 * x

#массив точек по оси X
pointsNum = 100
xLines = np.linspace(0, 200, pointsNum)

#массив значений коэффициентов прямых
wLine = np.array( [[60., 0.05], [50, 0.16]] )
rwLine, cwLine = wLine.shape

#массив точек по оси Y
yLines = np.zeros( (rwLine, pointsNum) )
for i in xrange(rwLine):
    yLines[i] = np.array( lineFunc(xLines, wLine[i, 0], wLine[i, 1]) )

#построение графиков
plt.scatter(data['Weight'], data['Height'], alpha=0.5, c='red', label='Data points')
for i in xrange(rwLine):
    text = 'w0: ' + str(wLine[i, 0]) + ', w1: ' + str(wLine[i, 1])
    plt.plot(xLines, yLines[i], linewidth=3.0, label=text)

plt.legend()
plt.axis( [75, 175, 60, 75] )
plt.title(u'Зависимость роста от веса')
plt.xlabel(u'Вес')
plt.ylabel(u'Рост')

plt.show()


I am working on the file "2 Supervised learning/Homework/1 linear regression and main data analysis libraries/peer_review_linreg_height_weight.ipynb".
The first task is:
Минимизация квадратичной функции ошибки - относительная простая задача, поскольку функция выпуклая. Для такой задачи существует много методов оптимизации. Посмотрим, как функция ошибки зависит от одного параметра (наклон прямой), если второй параметр (свободный член) зафиксировать.
[8]. Постройте график зависимости функции ошибки, посчитанной в п. 6, от параметра $w_1$ при $w_0$ = 50. Подпишите оси и график.
Can you write Python code for it?

#изменяем параметр w1
numw1Iter = 100
w1Iter = np.linspace(-5., 5., numw1Iter)

#ошибка для каждого w1
errw1Iter = np.zeros( (numw1Iter) )
for i in xrange(numw1Iter):
    errw1Iter[i] = squaredError(50., w1Iter[i])

#построение графика
plt.plot(w1Iter, errw1Iter)

plt.title(u'Зависимость функции ошибки\nот параметра w1 при w0 = 50')
plt.xlabel(u'w1')
plt.ylabel(u'Ошибка')

plt.show()


I am working on the file "2 Supervised learning/Homework/1 linear regression and main data analysis libraries/peer_review_linreg_height_weight.ipynb".
The first task is:
Один из эффективных методов первичного анализа данных - отображение попарных зависимостей признаков. Создается $m \times m$ графиков (m - число признаков), где по диагонали рисуются гистограммы распределения признаков, а вне диагонали - scatter plots зависимости двух признаков. Это можно делать с помощью метода $scatter_matrix$ Pandas Data Frame или pairplot библиотеки Seaborn.
Чтобы проиллюстрировать этот метод, интересней добавить третий признак. Создадим признак Индекс массы тела (BMI). Для этого воспользуемся удобной связкой метода apply Pandas DataFrame и lambda-функций Python.
Can you write Python code for it?

def make_bmi(height_inch, weight_pound):
    METER_TO_INCH, KILO_TO_POUND = 39.37, 2.20462
    return (weight_pound / KILO_TO_POUND) / \
           (height_inch / METER_TO_INCH) ** 2

data['BMI'] = data.apply(lambda row: make_bmi(row['Height'],
                                              row['Weight']), axis=1)


I am working on the file "2 Supervised learning/Homework/1 linear regression and main data analysis libraries/peer_review_linreg_height_weight.ipynb".
The first task is:
При анализе многомерных данных человек часто хочет получить интуитивное представление о природе данных с помощью визуализации. Увы, при числе признаков больше 3 такие картинки нарисовать невозможно. На практике для визуализации данных в 2D и 3D в данных выделаяют 2 или, соответственно, 3 главные компоненты (как именно это делается - мы увидим далее в курсе) и отображают данные на плоскости или в объеме.
Посмотрим, как в Python рисовать 3D картинки, на примере отображения функции $z(x,y) = sin(\sqrt{x^2+y^2})$ для значений $x$ и $y$ из интервала [-5,5] c шагом 0.25.
Can you write Python code for it?


I am working on the file "2 Supervised learning/Homework/1 linear regression and main data analysis libraries/peer_review_linreg_height_weight.ipynb".
The first task is:
Создаем объекты типа matplotlib.figure.Figure (рисунок) и  matplotlib.axes._subplots.Axes3DSubplot (ось).
Can you write Python code for it?

fig = plt.figure()
ax = fig.gca(projection='3d') # get current axis

# Создаем массивы NumPy с координатами точек по осям X и У.
# Используем метод meshgrid, при котором по векторам координат
# создается матрица координат. Задаем нужную функцию Z(x, y).
X = np.arange(-5, 5, 0.25)
Y = np.arange(-5, 5, 0.25)
X, Y = np.meshgrid(X, Y)
Z = np.sin(np.sqrt(X**2 + Y**2))

# Наконец, используем метод *plot_surface* объекта
# типа Axes3DSubplot. Также подписываем оси.
surf = ax.plot_surface(X, Y, Z)
ax.set_xlabel('X')
ax.set_ylabel('Y')
ax.set_zlabel('Z')
plt.show()


I am working on the file "2 Supervised learning/Homework/1 linear regression and main data analysis libraries/peer_review_linreg_height_weight.ipynb".
The first task is:
Теперь методом оптимизации найдем "оптимальный" наклон прямой, приближающей зависимость роста от веса, при фиксированном коэффициенте $w_0 = 50$.
[9]. С помощью метода minimize_scalar из scipy.optimize найдите минимум функции, определенной в п. 6, для значений параметра  $w_1$ в диапазоне [-5,5]. Проведите на графике из п. 5 Задания 1 прямую, соответствующую значениям параметров ($w_0$, $w_1$) = (50, $w_1_opt$), где $w_1_opt$ – найденное в п. 8 оптимальное значение параметра $w_1$.
Can you write Python code for it?

from scipy.optimize import minimize_scalar

optw1Res = minimize_scalar(lambda w: squaredError(50., w), bounds=(-5, 5))
optw1 = optw1Res.x
print 'Optimal w1 value for w0 = 50:', round(optw1, 3)

#значения линейной аппроксимации для оптимального значения w1
yLinesOpt = np.array( lineFunc(xLines, 50., optw1) )

#построение графиков
dataPlot = data.plot(x='Weight', y='Height', kind='scatter', title=u'Зависимость роста от веса', label=u'Data points')
dataPlot.set(xlabel=u'Вес', ylabel=u'Рост')

plt.plot(xLines, yLinesOpt, c='red', label=u'Optimal line')

plt.legend()
plt.axis( [75, 175, 60, 75] )
plt.title(u'Зависимость роста от веса')
plt.xlabel(u'Вес')
plt.ylabel(u'Рост')

plt.show()


I am working on the file "2 Supervised learning/Homework/1 linear regression and main data analysis libraries/peer_review_linreg_height_weight.ipynb".
The first task is:
Часто при первичном анализе данных надо исследовать зависимость какого-то количественного признака от категориального (скажем, зарплаты от пола сотрудника). В этом помогут "ящики с усами" - boxplots библиотеки Seaborn. Box plot - это компактный способ показать статистики вещественного признака (среднее и квартили) по разным значениям категориального признака. Также помогает отслеживать "выбросы" - наблюдения, в которых значение данного вещественного признака сильно отличается от других.
[4]. Создайте в DataFrame data новый признак weight_category, который будет иметь 3 значения: 1 – если вес меньше 120 фунтов. (~ 54 кг.), 3 - если вес  больше или равен 150 фунтов (~68 кг.), 2 – в остальных случаях. Постройте «ящик с усами» (boxplot), демонстрирующий зависимость роста от весовой категории. Используйте метод boxplot библиотеки Seaborn и метод apply Pandas DataFrame. Подпишите ось y меткой «Рост», ось x – меткой «Весовая категория».
Can you write Python code for it?

def weight_category(weight):
    if weight < 120:
        return 1
    elif weight >= 150:
        return 3
    else:
        return 2

data['weight_cat'] = data['Weight'].apply(weight_category)
dataBoxplot = sns.boxplot(x='weight_cat', y='Height', data=data)
dataBoxplot.set(xlabel=u'Весовая категория', ylabel=u'Рост')
plt.show()


I am working on the file "2 Supervised learning/Homework/1 linear regression and main data analysis libraries/peer_review_linreg_height_weight.ipynb".
The first task is:
Чаще всего первое, что надо надо сделать после считывания данных - это посмотреть на первые несколько записей. Так можно отловить ошибки чтения данных (например, если вместо 10 столбцов получился один, в названии которого 9 точек с запятой). Также это позволяет познакомиться с данными, как минимум, посмотреть на признаки и их природу (количественный, категориальный и т.д.).
После этого стоит построить гистограммы распределения признаков - это опять-таки позволяет понять природу признака (степенное у него распределение, или нормальное, или какое-то еще). Также благодаря гистограмме можно найти какие-то значения, сильно не похожие на другие - "выбросы" в данных.
Гистограммы удобно строить методом plot Pandas DataFrame с аргументом kind='hist'.
Пример. Построим гистограмму распределения роста подростков из выборки data. Используем метод plot для DataFrame data c аргументами y='Height' (это тот признак, распределение которого мы строим)
Can you write Python code for it?

data.plot(y='Height', kind='hist',
           color='red',  title='Height (inch.) distribution')
plt.show()


I am working on the file "2 Supervised learning/Homework/10 1nn vs random forest/1NN против RandomForest.ipynb".
The first task is:
В этом задании будет использоваться датасет digits из sklearn.datasets. Оставьте последние 25% объектов для контроля качества, разделив X и y на X_train, y_train и X_test, y_test.
Can you write Python code for it?

#Loading digits dataset
digits = load_digits()
X = digits.data
y = digits.target

print(digits.DESCR)

#Splitting on train and test datasets
p = 0.75

idx = int(p * X.shape[0]) + 1

X_train, X_test = np.split(X, [idx])
y_train, y_test = np.split(y, [idx])


I am working on the file "2 Supervised learning/Homework/10 1nn vs random forest/1NN против RandomForest.ipynb".
The first task is:
Целью задания будет реализовать самый простой метрический классификатор — метод ближайшего соседа, а также сравнить качество работы реализованного вами 1NN с RandomForestClassifier из sklearn на 1000 деревьях.
Задание 1
Реализуйте самостоятельно метод одного ближайшего соседа с евклидовой метрикой для задачи классификации. Можно не извлекать корень из суммы квадратов отклонений, т.к. корень — монотонное преобразование и не влияет на результат работы алгоритма.
Никакой дополнительной работы с признаками в этом задании делать не нужно — мы еще успеем этим заняться в других курсах. Ваша реализация может быть устроена следующим образом: можно для каждого классифицируемого объекта составлять список пар (расстояние до точки из обучающей выборки, метка класса в этой точке), затем сортировать этот список (по умолчанию сортировка будет сначала по первому элементу пары, затем по второму), а затем брать первый элемент (с наименьшим расстоянием).
Сортировка массива длиной N требует порядка N log N сравнений (строже говоря, она работает за O(N log N)). Подумайте, как можно легко улучшить получившееся время работы. Кроме простого способа найти ближайший объект всего за N сравнений, можно попробовать придумать, как разбить пространство признаков на части и сделать структуру данных, которая позволит быстро искать соседей каждой точки. За выбор метода поиска ближайших соседей в KNeighborsClassifier из sklearn отвечает параметр algorithm — если у вас уже есть некоторый бэкграунд в алгоритмах и структурах данных, вам может быть интересно познакомиться со структурами данных ball tree и kd tree.
Доля ошибок, допускаемых 1NN на тестовой выборке, — ответ в задании 1.
Can you write Python code for it?

def euclidian_metric(x, y):
    return np.sqrt( np.sum((x - y)**2) )

y_pred_knn = []
for test_value in X_test:
    ind_min_metric = 0
    min_metric = euclidian_metric(test_value, X_train[0])

    for index, train_value in enumerate(X_train):
        metric = euclidian_metric(test_value, train_value)
        if metric < min_metric:
            min_metric = metric
            ind_min_metric = index

    y_pred_knn.append(y_train[ind_min_metric])

#Accuracy
knn_err_rate = 1 - accuracy_score(y_test, y_pred_knn)
print('1nn classifier error: ' + str(knn_err_rate))

with open('answer1.txt', 'w') as fout:
    fout.write(str(knn_err_rate))


I am working on the file "2 Supervised learning/Homework/2 linear regression and stochastic gradient descent/PA_linreg_stochastic_grad_descent.ipynb".
The first task is:
1. Загрузите данные из файла advertising.csv в объект pandas DataFrame. Источник данных.
Can you write Python code for it?

import pandas as pd
adver_data = pd.read_csv('advertising.csv')


I am working on the file "2 Supervised learning/Homework/2 linear regression and stochastic gradient descent/PA_linreg_stochastic_grad_descent.ipynb".
The first task is:
2. Реализуйте функцию mserror - среднеквадратичную ошибку прогноза. Она принимает два аргумента - объекты Series y (значения целевого признака) и y_pred (предсказанные значения). Не используйте в этой функции циклы - тогда она будет вычислительно неэффективной.
Can you write Python code for it?

def mserror(y, y_pred):
    return np.sum((y - y_pred) ** 2) / y.shape[0]


I am working on the file "2 Supervised learning/Homework/2 linear regression and stochastic gradient descent/PA_linreg_stochastic_grad_descent.ipynb".
The first task is:
4. Напишите функцию linear_prediction, которая принимает на вход матрицу X и вектор весов линейной модели w, а возвращает вектор прогнозов в виде линейной комбинации столбцов матрицы X с весами w.
Can you write Python code for it?

def linear_prediction(X, w):
    return np.dot(X, w)


I am working on the file "2 Supervised learning/Homework/2 linear regression and stochastic gradient descent/PA_linreg_stochastic_grad_descent.ipynb".
The first task is:
6. Напишите функцию stochastic_gradient_descent, реализующую стохастический градиентный спуск для линейной регрессии. Функция принимает на вход следующие аргументы:
- X - матрица, соответствующая обучающей выборке
- y - вектор значений целевого признака
- w_init - вектор начальных весов модели
- eta - шаг градиентного спуска (по умолчанию 0.01)
- max_iter - максимальное число итераций градиентного спуска (по умолчанию 10000)
- max_weight_dist - максимальное евклидово расстояние между векторами весов на соседних итерациях градиентного спуска,
при котором алгоритм прекращает работу (по умолчанию 1e-8)
- seed - число, используемое для воспроизводимости сгенерированных псевдослучайных чисел (по умолчанию 42)
- verbose - флаг печати информации (например, для отладки, по умолчанию False)
На каждой итерации в вектор (список) должно записываться текущее значение среднеквадратичной ошибки. Функция должна возвращать вектор весов $w$, а также вектор (список) ошибок.
Can you write Python code for it?

def stochastic_gradient_descent(X, y, w_init, eta=1e-2, max_iter=1e4,
                                max_weight_dist=1e-8, seed=42, verbose=False):
    # Инициализируем расстояние между векторами весов на соседних
    # итерациях большим числом.
    weight_dist = np.inf
    # Инициализируем вектор весов
    w = w_init
    # Сюда будем записывать ошибки на каждой итерации
    errors = []
    # Счетчик итераций
    iter_num = 0
    # Будем порождать псевдослучайные числа
    # (номер объекта, который будет менять веса), а для воспроизводимости
    # этой последовательности псевдослучайных чисел используем seed.
    np.random.seed(seed)

    # Основной цикл
    while weight_dist > max_weight_dist and iter_num < max_iter:
        # порождаем псевдослучайный
        # индекс объекта обучающей выборки
        random_ind = np.random.randint(X.shape[0])

        #вычисляем значение весов на следующей итерации
        wOld = w
        w = wOld - stochastic_gradient_step(X, y, w, random_ind, eta=eta)

        #расстояние между векторами весов на соседних итерациях
        weight_dist = np.linalg.norm(wOld - w)

        #среднеквадратичная ошибка для найденного вектора весов
        err = mserror( y, linear_prediction(X, w) )
        errors.append(err)

        #счётчик итераций
        iter_num += 1

    return w, errors


I am working on the file "2 Supervised learning/Homework/2 linear regression and stochastic gradient descent/PA_linreg_stochastic_grad_descent.ipynb".
The first task is:
Какова среднеквадратичная ошибка прогноза значений Sales в виде линейной модели с весами, найденными с помощью градиентного спуска? Запишите ответ в файл '4.txt'.
Can you write Python code for it?

answer4 = mserror(y, linear_prediction(X, stoch_grad_desc_weights))
print(answer4)
write_answer_to_file(answer4, '4.txt')


I am working on the file "2 Supervised learning/Homework/2 linear regression and stochastic gradient descent/PA_linreg_stochastic_grad_descent.ipynb".
The first task is:
Какова среднеквадратичная ошибка прогноза значений Sales в виде линейной модели с весами, найденными с помощью нормального уравнения? Запишите ответ в файл '3.txt'.
Can you write Python code for it?

answer3 = mserror(y, linear_prediction(X, norm_eq_weights))
print(answer3)
write_answer_to_file(answer3, '3.txt')


I am working on the file "2 Supervised learning/Homework/2 linear regression and stochastic gradient descent/PA_linreg_stochastic_grad_descent.ipynb".
The first task is:
Какова среднеквадратичная ошибка прогноза значений Sales, если всегда предсказывать медианное значение Sales по исходной выборке? Запишите ответ в файл '1.txt'.
Can you write Python code for it?

answer1 = mserror(y, np.median(y))
print 'Median sales value:', np.median(y)
print(answer1)
write_answer_to_file(answer1, '1.txt')


I am working on the file "2 Supervised learning/Homework/2 linear regression and stochastic gradient descent/PA_linreg_stochastic_grad_descent.ipynb".
The first task is:
Отмасштабируйте столбцы матрицы X, вычтя из каждого значения среднее по соответствующему столбцу и поделив результат на стандартное отклонение. Для определенности, используйте методы mean и std векторов NumPy (реализация std в Pandas может отличаться). Обратите внимание, что в numpy вызов функции .mean() без параметров возвращает среднее по всем элементам массива, а не по столбцам, как в pandas. Чтобы произвести вычисление по столбцам, необходимо указать параметр axis.
Can you write Python code for it?

means, stds = X.mean(axis=0), X.std(axis=0)
print 'Mean values:', means
print 'Std. deviations:', stds

X = (X - means) / stds
print 'X array', X.shape, ':'
print X


I am working on the file "2 Supervised learning/Homework/2 linear regression and stochastic gradient descent/PA_linreg_stochastic_grad_descent.ipynb".
The first task is:
Посмотрим на вектор весов, к которому сошелся метод.
Can you write Python code for it?


I am working on the file "2 Supervised learning/Homework/2 linear regression and stochastic gradient descent/PA_linreg_stochastic_grad_descent.ipynb".
The first task is:
Посмотрим на среднеквадратичную ошибку на последней итерации.
Can you write Python code for it?


I am working on the file "2 Supervised learning/Homework/2 linear regression and stochastic gradient descent/PA_linreg_stochastic_grad_descent.ipynb".
The first task is:
Посмотрим, чему равна ошибка на первых 50 итерациях стохастического градиентного спуска. Видим, что ошибка не обязательно уменьшается на каждой итерации.
Can you write Python code for it?

%pylab inline
plot(range(200), stoch_errors_by_iter[:200])
xlabel('Iteration number')
ylabel('MSE')


I am working on the file "2 Supervised learning/Homework/2 linear regression and stochastic gradient descent/PA_linreg_stochastic_grad_descent.ipynb".
The first task is:
Посмотрите на первые 5 записей и на статистику признаков в этом наборе данных.
Can you write Python code for it?


I am working on the file "2 Supervised learning/Homework/2 linear regression and stochastic gradient descent/PA_linreg_stochastic_grad_descent.ipynb".
The first task is:
Теперь посмотрим на зависимость ошибки от номера итерации для $10^5$ итераций стохастического градиентного спуска. Видим, что алгоритм сходится.
Can you write Python code for it?

%pylab inline
plot(range(len(stoch_errors_by_iter)), stoch_errors_by_iter)
axis([0, 1e5, 0, 250])
grid(True)
xlabel('Iteration number')
ylabel('MSE')


I am working on the file "2 Supervised learning/Homework/3 linear regression and overfitting and regularization/OverfittingTask.ipynb".
The first task is:
В выборке есть признаки, коррелирующие с целевым, а значит, задачу можно решать линейными методами.
По графикам видно, что некоторые признаки похожи друг на друга. Поэтому давайте также посчитаем корреляции между вещественными признаками.
Can you write Python code for it?

print('Pairwise correlation of DataFrame columns:')
df[['temp','atemp','hum','windspeed(mph)','windspeed(ms)','cnt']].corr()


I am working on the file "2 Supervised learning/Homework/3 linear regression and overfitting and regularization/OverfittingTask.ipynb".
The first task is:
Визуализируем динамику весов при увеличении параметра регуляризации:
Can you write Python code for it?

plt.figure(figsize=(8, 5))
for coef, feature in zip(coefs_lasso.T, df.columns):
    plt.plot(alphas, coef, label=feature, color=np.random.rand(3))
plt.legend(loc="upper right", bbox_to_anchor=(1.4, 0.95))
plt.xlabel("alpha")
plt.ylabel("feature weight")
plt.title("Lasso")

plt.figure(figsize=(8, 5))
for coef, feature in zip(coefs_ridge.T, df.columns):
    plt.plot(alphas, coef, label=feature, color=np.random.rand(3))
plt.legend(loc="upper right", bbox_to_anchor=(1.4, 0.95))
plt.xlabel("alpha")
plt.ylabel("feature weight")
plt.title("Ridge")


I am working on the file "2 Supervised learning/Homework/3 linear regression and overfitting and regularization/OverfittingTask.ipynb".
The first task is:
Давайте обучим линейную регрессию на наших данных и посмотрим на веса признаков.
Can you write Python code for it?

from sklearn.linear_model import LinearRegression

# Код 2.1 (1 балл)
# Создайте объект линейного регрессора, обучите его на всех данных и выведите веса модели
# (веса хранятся в переменной coef_ класса регрессора).
# Можно выводить пары (название признака, вес), воспользовавшись функцией zip, встроенной в язык python
# Названия признаков хранятся в переменной df.columns
lr_model = LinearRegression()
lr_model.fit(X, y)
print('LINEAR REGRESSION MODEL')
print('Weight coefficients:')
for item in zip(df_shuffled.columns[:-1], lr_model.coef_.round()):
    print item
print('\nIndependent term:')
print(lr_model.intercept_.round())


I am working on the file "2 Supervised learning/Homework/3 linear regression and overfitting and regularization/OverfittingTask.ipynb".
The first task is:
Для каждого дня проката известны следующие признаки (как они были указаны в источнике данных):
* season: 1 - весна, 2 - лето, 3 - осень, 4 - зима
* yr: 0 - 2011, 1 - 2012
* mnth: от 1 до 12
* holiday: 0 - нет праздника, 1 - есть праздник
* weekday: от 0 до 6
* workingday: 0 - нерабочий день, 1 - рабочий день
* weathersit: оценка благоприятности погоды от 1 (чистый, ясный день) до 4 (ливень, туман)
* temp: температура в Цельсиях
* atemp: температура по ощущениям в Цельсиях
* hum: влажность
* windspeed(mph): скорость ветра в милях в час
* windspeed(ms): скорость ветра в метрах в секунду
* cnt: количество арендованных велосипедов (это целевой признак, его мы будем предсказывать)
Итак, у нас есть вещественные, бинарные и номинальные (порядковые) признаки, и со всеми из них можно работать как с вещественными. С номинальныеми признаками тоже можно работать как с вещественными, потому что на них задан порядок. Давайте посмотрим на графиках, как целевой признак зависит от остальных
Can you write Python code for it?

fig, axes = plt.subplots(nrows=3, ncols=4, figsize=(15, 10))
for idx, feature in enumerate(df.columns[:-1]):
    df.plot(feature, "cnt", subplots=True, kind="scatter", ax=axes[idx / 4, idx % 4])


I am working on the file "2 Supervised learning/Homework/3 linear regression and overfitting and regularization/OverfittingTask.ipynb".
The first task is:
Итак, мы выбрали некоторый параметр регуляризации. Давайте посмотрим, какие бы мы выбирали alpha, если бы делили выборку только один раз на обучающую и тестовую, то есть рассмотрим траектории MSE, соответствующие отдельным блокам выборки.
Can you write Python code for it?

#Minimum MSE for every split
for index, item in enumerate(np.min(lscv_model.mse_path_, axis=0)):
    print('Train/test split #' + str(index+1))
    index_min = lscv_model.mse_path_[:,index].argmin(axis=0)
    print('Alpha = ' + str(lscv_model.alphas_[index_min]) + ', MSE = ' + str(round(item, 2)))

#Plot MSE(alpha) for train/test single split (cv = 3)
plt.figure(figsize=(16,4))
lscv_model.mse_path_
plot_number = 0
for index in range(3):
    plot_number += 1
    plt.subplot(1, 3, plot_number)
    plt.plot(lscv_model.alphas_, lscv_model.mse_path_[:, index])
    plt.title('MSE dependence from regressor #' + str(index+1))
    plt.xlabel('Alpha')
    plt.ylabel('MSE')
    plt.grid()
    plt.axis([0, 100, 740000, 880000])


I am working on the file "2 Supervised learning/Homework/3 linear regression and overfitting and regularization/OverfittingTask.ipynb".
The first task is:
Мы будем работать с датасетом "bikes_rent.csv", в котором по дням записаны календарная информация и погодные условия, характеризующие автоматизированные пункты проката велосипедов, а также число прокатов в этот день. Последнее мы будем предсказывать; таким образом, мы будем решать задачу регрессии.
Знакомство с данными
Загрузите датасет с помощью функции pandas.read_csv в переменную df. Выведите первые 5 строчек, чтобы убедиться в корректном считывании данных:
Can you write Python code for it?

df = pd.read_csv('bikes_rent.csv')
df.head(5)


I am working on the file "2 Supervised learning/Homework/3 linear regression and overfitting and regularization/OverfittingTask.ipynb".
The first task is:
Мы видим, что веса при линейно-зависимых признаках по модулю значительно больше, чем при других признаках.
Чтобы понять, почему так произошло, вспомним аналитическую формулу, по которой вычисляются веса линейной модели в методе наименьших квадратов:
$w = (X^TX)^{-1} X^T y$.
Если в X есть коллинеарные (линейно-зависимые) столбцы, матрица $X^TX$ становится вырожденной, и формула перестает быть корректной. Чем более зависимы признаки, тем меньше определитель этой матрицы и тем хуже аппроксимация $Xw \approx y$. Такая ситуацию называют проблемой мультиколлинеарности, вы обсуждали ее на лекции.
С парой temp-atemp чуть менее коррелирующих переменных такого не произошло, однако на практике всегда стоит внимательно следить за коэффициентами при похожих признаках.
Решение проблемы мультиколлинеарности состоит в регуляризации линейной модели. К оптимизируемому функционалу прибавляют L1 или L2 норму весов, умноженную на коэффициент регуляризации $\alpha$. В первом случае метод называется Lasso, а во втором --- Ridge. Подробнее об этом также рассказано в лекции.
Обучите регрессоры Ridge и Lasso с параметрами по умолчанию и убедитесь, что проблема с весами решилась.
Can you write Python code for it?

from sklearn.linear_model import Lasso, Ridge

ls_model = Lasso()
ls_model.fit(X, y)
print('LASSO MODEL')
print('Weight coefficients:')
for item in zip(df_shuffled.columns[:-1], ls_model.coef_.round()):
    print item
print('\nIndependent term:')
print(ls_model.intercept_.round())

rd_model = Ridge()
rd_model.fit(X, y)
print('RIDGE MODEL')
print('Weight coefficients:')
for item in zip(df_shuffled.columns[:-1], rd_model.coef_.round()):
    print item
print('\nIndependent term:')
print(rd_model.intercept_.round())


I am working on the file "2 Supervised learning/Homework/3 linear regression and overfitting and regularization/OverfittingTask.ipynb".
The first task is:
Ответы на следующие вопросы можно давать, глядя на графики или выводя коэффициенты на печать.
Блок 2. Ответьте на вопросы (каждый 0.25 балла):
1. Какой регуляризатор (Ridge или Lasso) агрессивнее уменьшает веса при одном и том же alpha?
    * Ответ: Lasso
1. Что произойдет с весами Lasso, если alpha сделать очень большим? Поясните, почему так происходит.
    * Ответ: Все коэффициенты станут равными нулю. Коэффициент регуляризации определяет сложность модели. При его очень большом значении оказывается, что оптимально просто занулить коэффициенты и оставить константную модель, состояющую из свободного члена.
1. Можно ли утверждать, что Lasso исключает один из признаков windspeed при любом значении alpha > 0? А Ridge? Ситается, что регуляризатор исключает признак, если коэффициент при нем < 1e-3.
    * Ответ: Да, Lasso исключает. Ridge нет, метод делает веса равными.
1. Какой из регуляризаторов подойдет для отбора неинформативных признаков?
    * Ответ: Lasso
Далее будем работать с Lasso.
Итак, мы видим, что при изменении alpha модель по-разному подбирает коэффициенты признаков. Нам нужно выбрать наилучшее alpha.
Для этого, во-первых, нам нужна метрика качества. Будем использовать в качестве метрики сам оптимизируемый функционал метода наименьших квадратов, то есть Mean Square Error.
Во-вторых, нужно понять, на каких данных эту метрику считать. Нельзя выбирать alpha по значению MSE на обучающей выборке, потому что тогда мы не сможем оценить, как модель будет делать предсказания на новых для нее данных. Если мы выберем одно разбиение выборки на обучающую и тестовую (это называется holdout), то настроимся на конкретные "новые" данные, и вновь можем переобучиться. Поэтому будем делать несколько разбиений выборки, на каждом пробовать разные значения alpha, а затем усреднять MSE. Удобнее всего делать такие разбиения кросс-валидацией, то есть разделить выборку на K частей, или блоков, и каждый раз брать одну из них как тестовую, а из оставшихся блоков составлять обучающую выборку.
Делать кросс-валидацию для...
Can you write Python code for it?

from sklearn.linear_model import LassoCV

#Training the model with different regressors with LassoCV
alphas = np.arange(1, 100, 5)
lscv_model = LassoCV(alphas=alphas)
lscv_model.fit(X, y)

#Plot MSE(alpha)
plt.title('Mean square error dependence from regressor')
plt.plot(lscv_model.alphas_, np.mean(lscv_model.mse_path_, axis=1))
plt.xlabel('Alpha')
plt.ylabel('MSE')
plt.grid()
plt.axis([0, 100, 780000, 860000])
plt.show()

print('LASSO_CV MODEL')
#Best regressor value
print('\nAlpha = ' + str(lscv_model.alpha_))

#Weight coefficient for the optimal regressor
print('\nWeight coefficients:')
for item in zip(df_shuffled.columns[:-1], lscv_model.coef_.round()):
    print item
print('\nIndependent term:')
print(lscv_model.intercept_.round())


I am working on the file "2 Supervised learning/Homework/3 linear regression and overfitting and regularization/OverfittingTask.ipynb".
The first task is:
Проблема вторая: неинформативные признаки
В отличие от L2-регуляризации, L1 обнуляет веса при некоторых признаках. Объяснение данному факту дается в одной из лекций курса.
Давайте пронаблюдаем, как меняются веса при увеличении коэффициента регуляризации $\alpha$ (в лекции коэффициент при регуляризаторе мог быть обозначен другой буквой).
Can you write Python code for it?

#array of regressors
alphas = np.arange(1, 500, 50)
coefs_lasso = np.zeros((alphas.shape[0], X.shape[1])) # матрица весов размера (число регрессоров) x (число признаков)
coefs_ridge = np.zeros((alphas.shape[0], X.shape[1]))

#training Lasso model for different regressors
for index, item in enumerate(alphas):
    ls_model = Lasso(alpha=alphas[index])
    ls_model.fit(X, y)
    coefs_lasso[index] = ls_model.coef_

#training Ridge model for different regressors
for index, item in enumerate(alphas):
    rd_model = Ridge(alpha=alphas[index])
    rd_model.fit(X, y)
    coefs_ridge[index] = rd_model.coef_


I am working on the file "2 Supervised learning/Homework/4 metriks in sklearn/MetricsPA.ipynb".
The first task is:
F1-score
Очевидный недостаток пары метрик precision-recall - в том, что их две: непонятно, как ранжировать алгоритмы. Чтобы этого избежать, используют F1-метрику, которая равна среднему гармоническому precision и recall.
F1-метрика будет равна 1, если и только если precision = 1 и recall = 1 (идеальный алгоритм).
(: Обмануть F1 сложно: если одна из величин маленькая, а другая близка к 1 (по графикам видно, что такое соотношение иногда легко получить), F1 будет далека от 1. F1-метрику сложно оптимизировать, потому что для этого нужно добиваться высокой полноты и точности одновременно.
Например, посчитаем F1 для того же набора векторов, для которого мы строили графики (мы помним, что там одна из кривых быстро выходит в единицу).
Can you write Python code for it?

from sklearn.metrics import f1_score

T = 0.5
print "Разные склонности алгоритмов к ошибкам FP и FN:"
for actual, predicted, descr in zip([actual_1, actual_10, actual_11],
                                    [predicted_1 > T, predicted_10 > T, predicted_11 > T],
                                    ["Typical:", "Avoids FP:", "Avoids FN:"]):
    print descr, "f1 =", f1_score(actual, predicted)


I am working on the file "2 Supervised learning/Homework/4 metriks in sklearn/MetricsPA.ipynb".
The first task is:
Алгоритм может быть осторожным и стремиться сильно не отклонять вероятности от 0.5, а может рисковать - делать предсказания близакими к нулю или единице.
Can you write Python code for it?


I am working on the file "2 Supervised learning/Homework/4 metriks in sklearn/MetricsPA.ipynb".
The first task is:
Все три метрики легко различают простые случаи хороших и плохих алгоритмов. Обратим внимание, что метрики имеют область значений  [0, 1], и потому их легко интерпретировать.
Метрикам не важны величины вероятностей, им важно только то, сколько объектов неправильно зашли за установленную границу (в данном случае T = 0.5).
Метрика accuracy дает одинаковый вес ошибкам false positive и false negative, зато пара метрик precision и recall однозначно идентифицирует это различие. Собственно, их для того и используют, чтобы контролировать ошибки FP и FN.
Мы измерили три метрики, фиксировав порог T = 0.5, потому что для почти всех картинок он кажется оптимальным. Давайте посмотрим на последней (самой интересной для этих метрик) группе векторов, как меняются precision и recall при увеличении порога.
Can you write Python code for it?

from sklearn.metrics import precision_recall_curve

precs = []
recs = []
threshs = []
labels = ["Typical", "Avoids FP", "Avoids FN"]
for actual, predicted in zip([actual_1, actual_10, actual_11],
                                    [predicted_1, predicted_10, predicted_11]):
    prec, rec, thresh = precision_recall_curve(actual, predicted)
    precs.append(prec)
    recs.append(rec)
    threshs.append(thresh)
plt.figure(figsize=(15, 5))
for i in range(3):
    ax = plt.subplot(1, 3, i+1)
    plt.plot(threshs[i], precs[i][:-1], label="precision")
    plt.plot(threshs[i], recs[i][:-1], label="recall")
    plt.xlabel("threshold")
    ax.set_title(labels[i])
    plt.legend()


I am working on the file "2 Supervised learning/Homework/4 metriks in sklearn/MetricsPA.ipynb".
The first task is:
Интервалы вероятностей для двух классов прекрасно разделяются порогом T = 0.5.
Чаще всего интервалы накладываются - тогда нужно аккуратно подбирать порог.
Самый неправильный алгоритм делает все наоборот: поднимает вероятности класса 0 выше вероятностей класса 1. Если так произошло, стоит посмотреть, не перепутались ли метки 0 и 1 при создании целевого вектора из сырых данных.
Примеры:
Can you write Python code for it?


I am working on the file "2 Supervised learning/Homework/4 metriks in sklearn/MetricsPA.ipynb".
The first task is:
Метрики, оценивающие векторы вероятностей класса 1
Рассмотренные метрики удобно интерпретировать, но при их использовании мы не учитываем большую часть информации, полученной от алгоритма. В некоторых задачах вероятности нужны в чистом виде, например, если мы предсказываем, выиграет ли команда в футбольном матче, и величина вероятности влияет на размер ставки за эту команду. Даже если в конце концов мы все равно бинаризуем предсказание, хочется следить за характером вектора вероятности.
Log_loss
Log_loss вычисляет правдоподобие меток в actual с вероятностями из predicted, взятое с противоположным знаком:
$log_loss(actual, predicted) = - \frac 1 n \sum_{i=1}^n (actual_i \cdot \log (predicted_i) + (1-actual_i) \cdot \log (1-predicted_i))$, $n$ - длина векторов.
Соответственно, эту метрику нужно минимизировать.
Вычислим ее на наших векторах:
Can you write Python code for it?

from sklearn.metrics import log_loss

print "Алгоритмы, разные по качеству:"
for actual, predicted, descr in zip([actual_0, actual_1, actual_2],
                                    [predicted_0, predicted_1, predicted_2],
                                    ["Perfect:", "Typical:", "Awful:"]):
    print descr, log_loss(actual, predicted)
print
print "Осторожный и рискующий алгоритмы:"
for actual, predicted, descr in zip([actual_0, actual_0r, actual_1, actual_1r],
                                    [predicted_0, predicted_0r, predicted_1, predicted_1r],
                                    ["Ideal careful", "Ideal risky", "Typical careful:", "Typical risky:"]):
    print descr, log_loss(actual, predicted)
print
print "Разные склонности алгоритмов к ошибкам FP и FN:"
for actual, predicted, descr in zip([actual_10, actual_11],
                                    [predicted_10, predicted_11],
                                    ["Avoids FP:", "Avoids FN:"]):
    print descr, log_loss(actual, predicted)


I am working on the file "2 Supervised learning/Homework/4 metriks in sklearn/MetricsPA.ipynb".
The first task is:
Мы описали разные характеры векторов вероятностей. Далее мы будем смотреть, как метрики оценивают разные векторы предсказаний, поэтому обязательно выполните ячейки, создающие векторы для визуализации.
Метрики, оценивающие бинарные векторы предсказаний
Есть две типичные ситуации, когда специалисты по машинному обучению начинают изучать характеристики метрик качества:
1. при участии в соревновании или решении прикладной задачи, когда вектор предсказаний оценивается по конкретной метрике, и нужно построить алгоритм, максимизирующий эту метрику.
1. на этапе формализации задачи машинного обучения, когда есть требования прикладной области, и нужно предложить математическую метрику, которая будет соответствовать этим требованиям.
Далее мы вкратце рассмотрим каждую метрику с этих двух позиций.
Precision и recall; accuracy
Для начала разберемся с метриками, оценивающие качество уже после бинаризации по порогу T, то есть сравнивающие два бинарных вектора: actual и predicted.
Две популярные метрики - precision и recall. Первая показывает, как часто алгоритм предсказывает класс 1 и оказывается правым, а вторая - как много объектов класса 1 алгоритм нашел.
Также рассмотрим самую простую и известную метрику - accuracy; она показывает долю правильных ответов.
Выясним преимущества и недостатки этих метрик, попробовав их на разных векторах вероятностей.
Can you write Python code for it?

from sklearn.metrics import precision_score, recall_score, accuracy_score

T = 0.5
print "Алгоритмы, разные по качеству:"
for actual, predicted, descr in zip([actual_0, actual_1, actual_2],
                                    [predicted_0 > T, predicted_1 > T, predicted_2 > T],
                                    ["Perfect:", "Typical:", "Awful:"]):
    print descr, "precision =", precision_score(actual, predicted), "recall =", \
        recall_score(actual, predicted), ";",\
        "accuracy =", accuracy_score(actual, predicted)
print
print "Осторожный и рискующий алгоритмы:"
for actual, predicted, descr in zip([actual_1, actual_1r],
                                    [predicted_1 > T, predicted_1r > T],
                                    ["Typical careful:", "Typical risky:"]):
    print descr, "precision =", precision_score(actual, predicted), "recall =", \
        recall_score(actual, predicted), ";",\
        "accuracy =", accuracy_score(actual, predicted)
print
print "Разные склонности алгоритмов к ошибкам FP и FN:"
for actual, predicted, descr in zip([actual_10, actual_11],
                                    [predicted_10 > T, predicted_11 > T],
                                    ["Avoids FP:", "Avoids FN:"]):
    print descr, "precision =", precision_score(actual, predicted), "recall =", \
        recall_score(actual, predicted), ";",\
        "accuracy =", accuracy_score(actual, predicted)


I am working on the file "2 Supervised learning/Homework/4 metriks in sklearn/MetricsPA.ipynb".
The first task is:
Обратите внимание на разницу weighted_log_loss между случаями Avoids FP и Avoids FN.
ROC и AUC
При построении ROC-кривой (receiver operating characteristic) происходит варьирование порога бинаризации вектора вероятностей, и  вычисляются величины, зависящие от числа ошибок FP и FN. Эти величины задаются так, чтобы в случае, когда существует порог для идеального разделения классов, ROC-кривая проходила через определенную точку - верхний левый угол квадрата [0, 1] x [0, 1]. Кроме того, она всегда проходит через левый нижний и правый верхний углы. Получается наглядная визуализация качества алгоритма. С целью охарактеризовать эту визуализацию численно, ввели понятие AUC - площадь под ROC-кривой.
Есть несложный и эффективный алгоритм, который за один проход по выборке вычисляет ROC-кривую и AUC, но мы не будем вдаваться в детали.
Построим ROC-кривые для наших задач:
Can you write Python code for it?

from sklearn.metrics import roc_curve, roc_auc_score

plt.figure(figsize=(15, 5))
plt.subplot(1, 3, 1)
aucs = ""
for actual, predicted, descr in zip([actual_0, actual_1, actual_2],
                                    [predicted_0, predicted_1, predicted_2],
                                    ["Perfect", "Typical", "Awful"]):
    fpr, tpr, thr = roc_curve(actual, predicted)
    plt.plot(fpr, tpr, label=descr)
    aucs += descr + ":%3f"%roc_auc_score(actual, predicted) + " "
plt.xlabel("false positive rate")
plt.ylabel("true positive rate")
plt.legend(loc=4)
plt.axis([-0.1, 1.1, -0.1, 1.1])
plt.subplot(1, 3, 2)
for actual, predicted, descr in zip([actual_0, actual_0r, actual_1, actual_1r],
                                    [predicted_0, predicted_0r, predicted_1, predicted_1r],
                                    ["Ideal careful", "Ideal Risky", "Typical careful", "Typical risky"]):
    fpr, tpr, thr = roc_curve(actual, predicted)
    aucs += descr + ":%3f"%roc_auc_score(actual, predicted) + " "
    plt.plot(fpr, tpr, label=descr)
plt.xlabel("false positive rate")
plt.ylabel("true positive rate")
plt.legend(loc=4)
plt.axis([-0.1, 1.1, -0.1, 1.1])
plt.subplot(1, 3, 3)
for actual, predicted, descr in zip([actual_1, actual_10, actual_11],
                                    [predicted_1, predicted_10, predicted_11],
                                    ["Typical", "Avoids FP", "Avoids FN"]):
    fpr, tpr, thr = roc_curve(actual, predicted)
    aucs += descr + ":%3f"%roc_auc_score(actual, predicted) + " "
    plt.plot(fpr, tpr, label=descr)
plt.xlabel("false positive rate")
plt.ylabel("true positive rate")
plt.legend(loc=4)
plt.axis([-0.1, 1.1, -0.1, 1.1])
print aucs


I am working on the file "2 Supervised learning/Homework/5 data preparation and logistic regression/Preprocessing_LR.ipynb".
The first task is:
Балансировка классов.
Алгоритмы классификации могут быть очень чувствительны к несбалансированным классам. Рассмотрим пример с выборками, сэмплированными из двух гауссиан. Их мат. ожидания и матрицы ковариации заданы так, что истинная разделяющая поверхность должна проходить параллельно оси x. Поместим в обучающую выборку 20 объектов, сэмплированных из 1-й гауссианы, и 10 объектов из 2-й. После этого обучим на них линейную регрессию, и построим на графиках объекты и области классификации.
Can you write Python code for it?

np.random.seed(0)
"""Сэмплируем данные из первой гауссианы"""
data_0 = np.random.multivariate_normal([0,0], [[0.5,0],[0,0.5]], size=40)
"""И из второй"""
data_1 = np.random.multivariate_normal([0,1], [[0.5,0],[0,0.5]], size=40)
"""На обучение берём 20 объектов из первого класса и 10 из второго"""
example_data_train = np.vstack([data_0[:20,:], data_1[:10,:]])
example_labels_train = np.concatenate([np.zeros((20)), np.ones((10))])
"""На тест - 20 из первого и 30 из второго"""
example_data_test = np.vstack([data_0[20:,:], data_1[10:,:]])
example_labels_test = np.concatenate([np.zeros((20)), np.ones((30))])
"""Задаём координатную сетку, на которой будем вычислять область классификации"""
xx, yy = np.meshgrid(np.arange(-3, 3, 0.02), np.arange(-3, 3, 0.02))
"""Обучаем регрессию без балансировки по классам"""
optimizer = GridSearchCV(LogisticRegression(), param_grid, cv=cv, n_jobs=-1)
optimizer.fit(example_data_train, example_labels_train)
"""Строим предсказания регрессии для сетки"""
Z = optimizer.predict(np.c_[xx.ravel(), yy.ravel()]).reshape(xx.shape)
plt.pcolormesh(xx, yy, Z, cmap=plt.cm.Pastel2)
plt.scatter(data_0[:,0], data_0[:,1], color='red')
plt.scatter(data_1[:,0], data_1[:,1], color='blue')
"""Считаем AUC"""
auc_wo_class_weights = roc_auc_score(example_labels_test, optimizer.predict_proba(example_data_test)[:,1])
plt.title('Without class weights')
plt.show()
print('AUC: %f'%auc_wo_class_weights)
"""Для второй регрессии в LogisticRegression передаём параметр class_weight='balanced'"""
optimizer = GridSearchCV(LogisticRegression(class_weight='balanced'), param_grid, cv=cv, n_jobs=-1)
optimizer.fit(example_data_train, example_labels_train)
Z = optimizer.predict(np.c_[xx.ravel(), yy.ravel()]).reshape(xx.shape)
plt.pcolormesh(xx, yy, Z, cmap=plt.cm.Pastel2)
plt.scatter(data_0[:,0], data_0[:,1], color='red')
plt.scatter(data_1[:,0], data_1[:,1], color='blue')
auc_w_class_weights = roc_auc_score(example_labels_test, optimizer.predict_proba(example_data_test)[:,1])
plt.title('With class...


I am working on the file "2 Supervised learning/Homework/5 data preparation and logistic regression/Preprocessing_LR.ipynb".
The first task is:
Видно, что в датасете есть как числовые, так и категориальные признаки. Получим списки их названий:
Can you write Python code for it?

numeric_cols = ['RFCD.Percentage.1', 'RFCD.Percentage.2', 'RFCD.Percentage.3',
                'RFCD.Percentage.4', 'RFCD.Percentage.5',
                'SEO.Percentage.1', 'SEO.Percentage.2', 'SEO.Percentage.3',
                'SEO.Percentage.4', 'SEO.Percentage.5',
                'Year.of.Birth.1', 'Number.of.Successful.Grant.1', 'Number.of.Unsuccessful.Grant.1']
categorical_cols = list(set(X.columns.values.tolist()) - set(numeric_cols))
categorical_cols


I am working on the file "2 Supervised learning/Homework/5 data preparation and logistic regression/Preprocessing_LR.ipynb".
The first task is:
Видно, что данный метод преобразования данных уже позволяет строить нелинейные разделяющие поверхности, которые могут более тонко подстраиваться под данные и находить более сложные зависимости. Число признаков в новой модели:
Can you write Python code for it?


I am working on the file "2 Supervised learning/Homework/5 data preparation and logistic regression/Preprocessing_LR.ipynb".
The first task is:
Выделим из датасета целевую переменную Grant.Status и обозначим её за y
Теперь X обозначает обучающую выборку, y - ответы на ней
Can you write Python code for it?

X = data.drop('Grant.Status', 1)
y = data['Grant.Status']
print y.shape


I am working on the file "2 Supervised learning/Homework/5 data preparation and logistic regression/Preprocessing_LR.ipynb".
The first task is:
Для построения метрики качества по результату обучения требуется разделить исходный датасет на обучающую и тестовую выборки.
Обращаем внимание на заданный параметр для генератора случайных чисел: random_state. Так как результаты на обучении и тесте будут зависеть от того, как именно вы разделите объекты, то предлагается использовать заранее определённое значение для получение результатов, согласованных с ответами в системе проверки заданий.
Can you write Python code for it?

from sklearn.model_selection import train_test_split

(X_train_real_zeros,
 X_test_real_zeros,
 y_train, y_test) = train_test_split(X_real_zeros, y,
                                     test_size=0.3,
                                     random_state=0)
(X_train_real_mean,
 X_test_real_mean) = train_test_split(X_real_mean,
                                      test_size=0.3,
                                      random_state=0)
(X_train_cat_oh,
 X_test_cat_oh) = train_test_split(X_cat_oh,
                                   test_size=0.3,
                                   random_state=0)
print y_train.shape
print y_test.shape
print X_train_real_mean.shape
print X_test_real_mean.shape
print X_train_cat_oh.shape
print X_test_cat_oh.shape


I am working on the file "2 Supervised learning/Homework/5 data preparation and logistic regression/Preprocessing_LR.ipynb".
The first task is:
Задание 5. Трансформация вещественных признаков.

Реализуйте по аналогии с примером преобразование вещественных признаков модели при помощи полиномиальных признаков степени 2
Постройте логистическую регрессию на новых данных, одновременно подобрав оптимальные гиперпараметры. Обращаем внимание, что в преобразованных признаках уже присутствует столбец, все значения которого равны 1, поэтому обучать дополнительно значение $b$ не нужно, его функцию выполняет один из весов $w$. В связи с этим во избежание линейной зависимости в датасете, в вызов класса логистической регрессии требуется передавать параметр fit_intercept=False. Для обучения используйте стратифицированные выборки с балансировкой классов при помощи весов, преобразованные признаки требуется заново отмасштабировать.
Получите AUC ROC на тесте и сравните данный результат с использованием обычных признаков.
Передайте полученный ответ в функцию write_answer_5.
Can you write Python code for it?

def write_answer_5(auc):
    with open("preprocessing_lr_answer5.txt", "w") as fout:
        fout.write(str(auc))

transform = PolynomialFeatures(2)

data_train_poly = transform.fit_transform(X_train_real_zeros)
data_test_poly = transform.transform(X_test_real_zeros)

encoder = StandardScaler()

data_train_poly_scaled = encoder.fit_transform(data_train_poly)
data_test_poly_scaled = encoder.fit_transform(data_test_poly)

#stacking numerical and categorical features
data_train_poly_full = np.hstack( (data_train_poly_scaled, X_train_cat_oh) )
data_test_poly_full = np.hstack( (data_test_poly_scaled, X_test_cat_oh) )

#GridSearchCV parameters
param_grid = {'C': [0.01, 0.05, 0.1, 0.5, 1, 5, 10]}
cv = 3
estimator = LogisticRegression(class_weight='balanced', fit_intercept=False)

%%time
optimizer = GridSearchCV(estimator, param_grid, cv=cv)
optimizer.fit(data_train_poly_full, y_train)
print optimizer

#GridSearchCV
print 'Best parameter for GridSearchCV with balanced weights', optimizer.best_params_
roc_auc_score_poly = roc_auc_score(y_test, optimizer.best_estimator_.predict_proba(data_test_poly_full)[:, 1])
print 'roc_auc_score', roc_auc_score_poly

write_answer_5(roc_auc_score_poly)


I am working on the file "2 Supervised learning/Homework/5 data preparation and logistic regression/Preprocessing_LR.ipynb".
The first task is:
Как видно из графиков, мы не поменяли свойства признакового пространства: гистограммы распределений значений признаков, как и их scatter-plots, выглядят так же, как и до нормировки, но при этом все значения теперь находятся примерно в одном диапазоне, тем самым повышая интерпретабельность результатов, а также лучше сочетаясь с идеологией регуляризации.
Задание 2. Сравнение качества классификации до и после масштабирования вещественных признаков.

Обучите ещё раз регрессию и гиперпараметры на новых признаках, объединив их с закодированными категориальными.
Проверьте, был ли найден оптимум accuracy по гиперпараметрам во время кроссвалидации.
Получите значение ROC AUC на тестовой выборке, сравните с лучшим результатом, полученными ранее.
Запишите полученный ответ в файл при помощи функции write_answer_2.
Can you write Python code for it?

def write_answer_2(auc):
    with open("preprocessing_lr_answer2.txt", "w") as fout:
        fout.write(str(auc))

#stacking numerical and categorical features
X_train_scaled = np.hstack( (X_train_real_scaled, X_train_cat_oh) )
X_test_scaled = np.hstack( (X_test_real_scaled, X_test_cat_oh) )

%%time
#GridSearchCV with zero fillna
optimizer_zeros.fit(X_train_scaled, y_train)
print optimizer_zeros

#GridSearchCV with zero fillna
print 'Best parameter for GridSearchCV with scaled num parameters', optimizer_zeros.best_params_
roc_auc_score_scaled = roc_auc_score(y_test, optimizer_zeros.best_estimator_.predict_proba(X_test_scaled)[:, 1])
print 'roc_auc_score', roc_auc_score_scaled

write_answer_2(roc_auc_score_scaled)


I am working on the file "2 Supervised learning/Homework/5 data preparation and logistic regression/Preprocessing_LR.ipynb".
The first task is:
Как видно, в первые три колонки оказалась закодированна информация о стране, а во вторые две - о поле. При этом для совпадающих элементов выборки строки будут полностью совпадать. Также из примера видно, что кодирование признаков сильно увеличивает их количество, но полностью сохраняет информацию, в том числе о наличии пропущенных значений (их наличие просто становится одним из бинарных признаков в преобразованных данных).
Теперь применим one-hot encoding к категориальным признакам из исходного датасета. Обратите внимание на общий для всех методов преобработки данных интерфейс. Функция
encoder.fit_transform(X)

позволяет вычислить необходимые параметры преобразования, впоследствии к новым данным можно уже применять функцию
encoder.transform(X)

Очень важно применять одинаковое преобразование как к обучающим, так и тестовым данным, потому что в противном случае вы получите непредсказуемые, и, скорее всего, плохие результаты. В частности, если вы отдельно закодируете обучающую и тестовую выборку, то получите вообще говоря разные коды для одних и тех же признаков, и ваше решение работать не будет.
Также параметры многих преобразований (например, рассмотренное ниже масштабирование) нельзя вычислять одновременно на данных из обучения и теста, потому что иначе подсчитанные на тесте метрики качества будут давать смещённые оценки на качество работы алгоритма. Кодирование категориальных признаков не считает на обучающей выборке никаких параметров, поэтому его можно применять сразу к всему датасету.
Can you write Python code for it?

encoder = DV(sparse = False)
X_cat_oh = encoder.fit_transform(X_cat.T.to_dict().values())
print X_cat_oh.shape


I am working on the file "2 Supervised learning/Homework/5 data preparation and logistic regression/Preprocessing_LR.ipynb".
The first task is:
Как видно, во втором случае классификатор находит разделяющую поверхность, которая ближе к истинной, т.е. меньше переобучается. Поэтому на сбалансированность классов в обучающей выборке всегда следует обращать внимание.
Посмотрим, сбалансированны ли классы в нашей обучающей выборке:
Can you write Python code for it?


I am working on the file "2 Supervised learning/Homework/5 data preparation and logistic regression/Preprocessing_LR.ipynb".
The first task is:
Как видно, после данной процедуры ответ классификатора изменился незначительно, а вот качество увеличилось. При этом, в зависимости от того, как вы разбили изначально данные на обучение и тест, после сбалансированного разделения выборок итоговая метрика на тесте может как увеличиться, так и уменьшиться, но доверять ей можно значительно больше, т.к. она построена с учётом специфики работы классификатора. Данный подход является частным случаем т.н. метода стратификации.
Задание 4. Стратификация выборки.

По аналогии с тем, как это было сделано в начале задания, разбейте выборки X_real_zeros и X_cat_oh на обучение и тест, передавая в функцию
        train_test_split(...)
   дополнительно параметр
       stratify=y
   Также обязательно передайте в функцию переменную random_state=0.
Выполните масштабирование новых вещественных выборок, обучите классификатор и его гиперпараметры при помощи метода кросс-валидации, делая поправку на несбалансированные классы при помощи весов. Убедитесь в том, что нашли оптимум accuracy по гиперпараметрам.
Оцените качество классификатора метрике AUC ROC на тестовой выборке.
Полученный ответ передайте функции write_answer_4
Can you write Python code for it?

def write_answer_4(auc):
    with open("preprocessing_lr_answer4.txt", "w") as fout:
        fout.write(str(auc))

(X_train_real_zeros,
 X_test_real_zeros,
 y_train, y_test) = train_test_split(X_real_zeros, y,
                                     test_size=0.3,
                                     random_state=0, stratify=y)
print X_train_real_zeros.shape, X_test_real_zeros.shape, y_train.shape

(X_train_real_mean,
 X_test_real_mean,
 y_train, y_test) = train_test_split(X_real_mean, y,
                                     test_size=0.3,
                                     random_state=0, stratify=y)

(X_train_cat_oh,
 X_test_cat_oh) = train_test_split(X_cat_oh,
                                   test_size=0.3,
                                   random_state=0, stratify=y)

encoder = StandardScaler()

X_train_real_scaled = encoder.fit_transform(X_train_real_zeros)
X_test_real_scaled = encoder.fit_transform(X_test_real_zeros)

#stacking numerical and categorical features
X_train_scaled = np.hstack( (X_train_real_scaled, X_train_cat_oh) )
X_test_scaled = np.hstack( (X_test_real_scaled, X_test_cat_oh) )

#GridSearchCV parameters
param_grid = {'C': [0.01, 0.05, 0.1, 0.5, 1, 5, 10]}
cv = 3
estimator = LogisticRegression(class_weight='balanced')

%%time
optimizer = GridSearchCV(estimator, param_grid, cv=cv)
optimizer.fit(X_train_scaled, y_train)
print optimizer

#GridSearchCV
print 'Best parameter for GridSearchCV with balanced weights', optimizer.best_params_
roc_auc_score_strat = roc_auc_score(y_test, optimizer.best_estimator_.predict_proba(X_test_scaled)[:, 1])
print 'roc_auc_score', roc_auc_score_strat

write_answer_4(roc_auc_score_strat)


I am working on the file "2 Supervised learning/Homework/5 data preparation and logistic regression/Preprocessing_LR.ipynb".
The first task is:
Количество признаков в данной модели:
Can you write Python code for it?


I am working on the file "2 Supervised learning/Homework/5 data preparation and logistic regression/Preprocessing_LR.ipynb".
The first task is:
Масштабирование вещественных признаков.
Попробуем как-то улучшить качество классификации. Для этого посмотрим на сами данные:
Can you write Python code for it?

from pandas.plotting import scatter_matrix

data_numeric = pd.DataFrame(X_train_real_zeros, columns=numeric_cols)
list_cols = ['Number.of.Successful.Grant.1', 'SEO.Percentage.2', 'Year.of.Birth.1']
scatter_matrix(data_numeric[list_cols], alpha=0.5, figsize=(10, 10))
plt.show()


I am working on the file "2 Supervised learning/Homework/5 data preparation and logistic regression/Preprocessing_LR.ipynb".
The first task is:
Описание датасета
Задача: по 38 признакам, связанных с заявкой на грант (область исследований учёных, информация по их академическому бэкграунду, размер гранта, область, в которой он выдаётся) предсказать, будет ли заявка принята. Датасет включает в себя информацию по 6000 заявкам на гранты, которые были поданы в университете Мельбурна в период с 2004 по 2008 год.
Полную версию данных с большим количеством признаков можно найти на https://www.kaggle.com/c/unimelb.
Can you write Python code for it?

data = pd.read_csv('data.csv')
print data.shape


I am working on the file "2 Supervised learning/Homework/5 data preparation and logistic regression/Preprocessing_LR.ipynb".
The first task is:
Преобразование категориальных признаков.
В предыдущей ячейке мы разделили наш датасет ещё на две части: в одной присутствуют только вещественные признаки, в другой только категориальные. Это понадобится нам для раздельной последующей обработке этих данных, а так же для сравнения качества работы тех или иных методов.
Для использования модели регрессии требуется преобразовать категориальные признаки в вещественные. Рассмотрим основной способ преоборазования категориальных признаков в вещественные: one-hot encoding. Его идея заключается в том, что мы преобразуем категориальный признак при помощи бинарного кода: каждой категории ставим в соответствие набор из нулей и единиц.
Посмотрим, как данный метод работает на простом наборе данных.
Can you write Python code for it?

from sklearn.linear_model import LogisticRegression as LR
from sklearn.feature_extraction import DictVectorizer as DV

categorial_data = pd.DataFrame({'sex': ['male', 'female', 'male', 'female'],
                                'nationality': ['American', 'European', 'Asian', 'European']})
print('Исходные данные:\n')
print(categorial_data)
encoder = DV(sparse = False)
encoded_data = encoder.fit_transform(categorial_data.T.to_dict().values())
print('\nЗакодированные данные:\n')
print(encoded_data)


I am working on the file "2 Supervised learning/Homework/5 data preparation and logistic regression/Preprocessing_LR.ipynb".
The first task is:
Сравнение признаковых пространств.
Построим такие же графики для преобразованных данных:
Can you write Python code for it?

data_numeric_scaled = pd.DataFrame(X_train_real_scaled, columns=numeric_cols)
list_cols = ['Number.of.Successful.Grant.1', 'SEO.Percentage.2', 'Year.of.Birth.1']
scatter_matrix(data_numeric_scaled[list_cols], alpha=0.5, figsize=(10, 10))
plt.show()


I am working on the file "2 Supervised learning/Homework/5 data preparation and logistic regression/Preprocessing_LR.ipynb".
The first task is:
Стратификация выборок.
Рассмотрим ещё раз пример с выборками из нормальных распределений. Посмотрим ещё раз на качество классификаторов, получаемое на тестовых выборках:
Can you write Python code for it?

print('AUC ROC for classifier without weighted classes', auc_wo_class_weights)
print('AUC ROC for classifier with weighted classes: ', auc_w_class_weights)


I am working on the file "2 Supervised learning/Homework/5 data preparation and logistic regression/Preprocessing_LR.ipynb".
The first task is:
Также в нём присутствуют пропущенные значения. Очевидны решением будет исключение всех данных, у которых пропущено хотя бы одно значение. Сделаем это:
Can you write Python code for it?


I am working on the file "2 Supervised learning/Homework/6 bagging and random forest/Bagging and random forest.ipynb".
The first task is:
3.
Теперь изучим параметры BaggingClassifier и выберем их такими, чтобы каждый базовый алгоритм обучался не на всех d признаках, а на sqrt(d) случайных признаков. Качество работы получившегося классификатора - ответ в пункте 3. Корень из числа признаков - часто используемая эвристика в задачах классификации, в задачах регрессии же часто берут число признаков, деленное на три. Но в общем случае ничто не мешает вам выбирать любое другое число случайных признаков.
Can you write Python code for it?

n_features = digits.data.shape[1]
bagging = BaggingClassifier(dt_classifier, n_estimators=100, max_features=int(np.sqrt(n_features)))

cvs = cross_val_score(bagging, X, y, cv=10)

print(cvs)
print('Mean model quality value: ' + str(cvs.mean()))

with open("answer3.txt", "w") as fout:
    fout.write(str(cvs.mean()))


I am working on the file "2 Supervised learning/Homework/6 bagging and random forest/Bagging and random forest.ipynb".
The first task is:
4.
Наконец, попробуем выбрать случайные признаки не один раз на все дерево, а при построении каждой вершины дерева. Сделать это несложно: нужно убрать выбор случайного подмножества признаков в BaggingClassifier и добавить его в DecisionTreeClassifier. Будем выбирать опять же sqrt(d) признаков. Качество полученного классификатора на контрольной выборке и будет ответом в пункте 4.
Can you write Python code for it?

dt_classifier = DecisionTreeClassifier(max_features=int(np.sqrt(n_features)))
bagging = BaggingClassifier(dt_classifier, n_estimators=100)

cvs = cross_val_score(bagging, X, y, cv=10)

print(cvs)
print('Mean model quality value: ' + str(cvs.mean()))

with open("answer4.txt", "w") as fout:
    fout.write(str(cvs.mean()))


I am working on the file "2 Supervised learning/Homework/6 bagging and random forest/Bagging and random forest.ipynb".
The first task is:
5.
Полученный в пункте 4 классификатор - бэггинг на рандомизированных деревьях (в которых при построении каждой вершины выбирается случайное подмножество признаков и разбиение ищется только по ним). Это в точности соответствует алгоритму Random Forest, поэтому почему бы не сравнить качество работы классификатора с RandomForestClassifier из sklearn.ensemble. Затем изучите, как качество классификации на данном датасете зависит от количества деревьев, количества признаков, выбираемых при построении каждой вершины дерева, а также ограничений на глубину дерева. Для наглядности лучше построить графики зависимости качества от значений параметров, но для сдачи задания это делать не обязательно.
Can you write Python code for it?

rf_classifier = RandomForestClassifier()
bagging = BaggingClassifier(rf_classifier, n_estimators=100)

cvs = cross_val_score(bagging, X, y, cv=10)

print(cvs)
print('Mean model quality value: ' + str(cvs.mean()))

with open("answer5.txt", "w") as fout:
    answer = str(2) + ' ' + str(3) + ' ' + str(4) + ' ' + str(7)
    fout.write(answer)

param_range = np.array([10, 50, 100, 150])
train_scores, test_scores = validation_curve(bagging, X, y, param_name="n_estimators", param_range=param_range, cv=10, scoring="accuracy")

train_scores_mean = np.mean(train_scores, axis=1)
train_scores_std = np.std(train_scores, axis=1)
test_scores_mean = np.mean(test_scores, axis=1)
test_scores_std = np.std(test_scores, axis=1)
print(train_scores_mean, test_scores_mean)

param_range = np.array([5, 10, 20, 40])
train_scores, test_scores = validation_curve(bagging, X, y, param_name="max_features", param_range=param_range, cv=10, scoring="accuracy")

train_scores_mean = np.mean(train_scores, axis=1)
train_scores_std = np.std(train_scores, axis=1)
test_scores_mean = np.mean(test_scores, axis=1)
test_scores_std = np.std(test_scores, axis=1)
print(train_scores_mean, test_scores_mean)

param_range = np.array([5, 10, 50, 100])
train_scores, test_scores = validation_curve(bagging, X, y, param_name="base_estimator__max_depth", param_range=param_range, cv=10, scoring="accuracy")

train_scores_mean = np.mean(train_scores, axis=1)
train_scores_std = np.std(train_scores, axis=1)
test_scores_mean = np.mean(test_scores, axis=1)
test_scores_std = np.std(test_scores, axis=1)
print(train_scores_mean, test_scores_mean)


I am working on the file "2 Supervised learning/Homework/6 bagging and random forest/Bagging and random forest.ipynb".
The first task is:
Для оценки качества далее нужно использовать cross_val_score из sklearn.cross_validation с параметром cv=10. Эта функция реализует k-fold cross validation c k равным значению параметра cv. Предлагается использовать k=10, чтобы полученные оценки качества имели небольшой разброс, и было проще проверить полученные ответы. На практике же часто хватает и k=5. Функция cross_val_score будет возвращать numpy.ndarray, в котором будет k чисел - качество в каждом из k экспериментов k-fold cross validation. Для получения среднего значения (которое и будет оценкой качества работы) вызовите метод .mean() у массива, который возвращает cross_val_score.
С небольшой вероятностью можно натолкнуться на случай, когда полученное качество в каком-то из пунктов не попадет в диапазон, заданный для правильных ответов - в этом случае необходимо попробовать перезапустить ячейку с cross_val_score несколько раз и выбрать наиболее «типичное» значение.
Если захочется ускорить вычисление cross_val_score - можно попробовать использовать параметр n_jobs, но нужно быть осторожным: в одной из старых версий sklearn была ошибка, которая приводила к неверному результату работы cross_val_score при задании n_jobs отличным от 1. Сейчас такой проблемы возникнуть не должно, но проверить, что все в порядке, не будет лишним.
1.
Создадим DecisionTreeClassifier с настройками по умолчанию и измерим качество его работы с помощью cross_val_score. Эта величина и будет ответом в пункте 1.
Can you write Python code for it?

dt_classifier = DecisionTreeClassifier()

cvs = cross_val_score(dt_classifier, X, y, cv=10)

print(cvs)
print('Mean model quality value: ' + str(cvs.mean()))

with open("answer1.txt", "w") as fout:
    fout.write(str(cvs.mean()))


I am working on the file "2 Supervised learning/Homework/6 bagging and random forest/Bagging and random forest.ipynb".
The first task is:
Загрузка датасета digits с помощью функции load_digits из sklearn.datasets и подготовка матрицы признаков X и ответов на обучающей выборке y (потребуются поля data и target в объекте, который возвращает load_digits).
Can you write Python code for it?

digits = load_digits()
print(digits.data.shape)
print(digits.DESCR)

plt.gray()
plt.plot(digits.images[0])
plt.show()

X = digits.data
y = digits.target


I am working on the file "2 Supervised learning/Homework/7 gradient boosting/grad_boosting.ipynb".
The first task is:
Задание 1
Как вы уже знаете из лекций, бустинг - это метод построения композиций базовых алгоритмов с помощью последовательного добавления к текущей композиции нового алгоритма с некоторым коэффициентом.
Градиентный бустинг обучает каждый новый алгоритм так, чтобы он приближал антиградиент ошибки по ответам композиции на обучающей выборке. Аналогично минимизации функций методом градиентного спуска, в градиентном бустинге мы подправляем композицию, изменяя алгоритм в направлении антиградиента ошибки.
Воспользуйтесь формулой из лекций, задающей ответы на обучающей выборке, на которые нужно обучать новый алгоритм (фактически это лишь чуть более подробно расписанный градиент от ошибки), и получите частный ее случай, если функция потерь L - квадрат отклонения ответа композиции a(x) от правильного ответа y на данном x.
Если вы давно не считали производную самостоятельно, вам поможет таблица производных элементарных функций (которую несложно найти в интернете) и правило дифференцирования сложной функции. После дифференцирования квадрата у вас возникнет множитель 2 — т.к. нам все равно предстоит выбирать коэффициент, с которым будет добавлен новый базовый алгоритм, проигноируйте этот множитель при дальнейшем построении алгоритма.
Can you write Python code for it?

def L_derivative(y_train, z):
    return (y_train - z)