I am working on the file "C_lab2_NNs/Hand_Digit_with_NN_student.ipynb".
The first task is:
3.2. Nearest Neighbor Method
In this section, you will analyze the performance of the nearest neighbor (1-NN) algorithm. The complexity of this algorithm grows with the size of the training set, so it is proposed to analyze the behavior of the algorithm for a variable size of the training set.
Exercise 3.2: Use the 1-NN method with a varying training set size. Obtain for each size:

The average classifiation error rate calculated on the test set
The fit time for the 1-NN method
The time taken to classify the complete test partition (10000 samples)
Can you write Python code for it?

from sklearn.neighbors import KNeighborsClassifier
import time

train_size = [250, 500, 1000, 2000, 5000, 10000, 25000, 60000]
fit_time = []
test_time = []
CE = []

for ntrain in train_size:
    print('Classifying with', ntrain, 'samples')
    # Write your code here
    # <SOL>
    # </SOL>

plt.figure(figsize=(15,3.5))
plt.subplot(1, 3, 1), plt.plot(train_size, 100*np.array(CE)), plt.xlabel('Training Set Size'), plt.ylabel('(%)'), plt.title('CE')
plt.subplot(1, 3, 2), plt.plot(train_size, fit_time), plt.xlabel('Training Set Size'), plt.ylabel('Seconds'), plt.title('Fit Time')
plt.subplot(1, 3, 3), plt.plot(train_size, test_time), plt.xlabel('Training Set Size'), plt.ylabel('Seconds'), plt.title('Test Time')
plt.show()
print('Average Classification Error for the 1-NN approach', 100*np.min(CE))


I am working on the file "C_lab2_NNs/Hand_Digit_with_NN_student.ipynb".
The first task is:
3.3. Multi-Layer Perceptron
Exercise 3.4: Train an MLP network using all samples in the training set. Use the following settings:
   - relu activation function for the hidden units
   - Two hidden layers with 200 and 100 neurons, respectively
   - Maximum number of iterations for the training: 2000 iterations
Compare the performance of the MLP network with that of the 1-NN method. Consider in your comparison both the classification error rate and the fit and operation times.
Calculate also the negative log likelihood of the model implemented by the Neural Network.
Can you write Python code for it?

from sklearn.neural_network import MLPClassifier

MLP = MLPClassifier(activation='relu', max_iter=2000, hidden_layer_sizes=(200,100))

# <SOL>
# </SOL>
print('Negative Log Likelihood for the MLP classifier:', NLL_MLP)


I am working on the file "C_lab2_NNs/Hand_Digit_with_NN_student.ipynb".
The first task is:
5.2. Network Optimization
We cover in this subsection two different aspects about network training using PyTorch:

Using torch.optim allows an easier and more interpretable encoding of neural network training, and opens the door to more sophisticated training algorithms

Using minibatches can speed up network convergence. The idea of minibatches is that, at each epoch, gradients are evaluated over just a subset of the training input data. Training of the network will normally require more epochs but, as each epoch requires the evaluation of the network output for a smaller subset of training samples, the overall training time is normally reduced significantly.

torch.optim provides two convenient methods for neural network training:
   * opt.step() updates all network parameters using current gradients
   * opt.zero_grad() resets all network parameters
Can you write Python code for it?

from torch.utils.data import TensorDataset, DataLoader

train_ds = TensorDataset(X_tr_torch, y_tr_torch)
train_dl = DataLoader(train_ds, batch_size=64)

from torch import optim

my_net = my_multiclass_net(X_tr_torch.size()[1], y_tr_torch.size()[1])
opt = optim.SGD(my_net.parameters(), lr=0.1)

epochs = 150

loss_tr = np.zeros(epochs)
loss_val = np.zeros(epochs)
CE_tr = np.zeros(epochs)
CE_val = np.zeros(epochs)

start = time.time()
for epoch in range(epochs):

    print(f'Current epoch: {epoch+1}    \r', end="")

    # In each epoch we iterate over all minibatches
    for xb, yb in train_dl:

        #Compute network output and cross-entropy loss for current minibatch
        pred = my_net(xb)
        loss = loss_func(pred, yb.argmax(axis=-1))

        #Compute gradients and optimize parameters
        loss.backward()
        opt.step()
        opt.zero_grad()

    #At the end of each epoch, evaluate overall network performance
    with torch.no_grad():
        #Computing network performance after iteration
        pred = my_net(X_tr_torch)
        loss_tr[epoch] = loss_func(pred, y_tr_torch.argmax(axis=-1)).item()
        CE_tr[epoch] = CE(y_tr_torch, pred).item()
        pred_val = my_net(X_val_torch)
        loss_val[epoch] = loss_func(pred_val, y_val_torch.argmax(axis=-1)).item()
        CE_val[epoch] = CE(y_val_torch, pred_val).item()

print('Neural Network training completed in', time.time()-start, 'seconds')

plt.figure(figsize=(14,5))
plt.subplot(1, 2, 1), plt.plot(loss_tr, 'b'), plt.plot(loss_val, 'r'), plt.legend(['train', 'val']), plt.title('Cross-entropy loss')
plt.subplot(1, 2, 2), plt.plot(100*CE_tr, 'b'), plt.plot(100*CE_val, 'r'), plt.legend(['train', 'val']), plt.title('Classification Error (%)')
plt.show()


I am working on the file "C_lab2_NNs/Hand_Digit_with_NN_student.ipynb".
The first task is:
<font color='teal'> 2. Binary classification </font>
2.1. Two dimensional representation
In order to be able to represent the classification frontier, we will begin our exploration by working on the two variables that present the greatest dispersion. To do this, we will use the Principal Component Analysis (PCA) algorithm.
2.1.1. Principal Component Analysis (PCA)
Exercise 2.1: Obtain the first two PCA projections for the binary classification problem. Store your results in the variables X_tr_2D andX_tst_2D. Make a scatter plot of these dimensions distinguishing the points corresponding to both classes, and reflect on the type of classification frontier that would provide a lower error rate.
Can you write Python code for it?

from sklearn.decomposition import PCA

# <SOL>
# </SOL>

plt.figure(figsize=(7,5))
plt.scatter(X_tr_2D[:, 0], X_tr_2D[:, 1],
            c=y_tr_bin, edgecolor='none', alpha=0.5,
            cmap=plt.cm.get_cmap('rainbow', 10))
plt.xlabel('component 1')
plt.ylabel('component 2')
plt.colorbar();


I am working on the file "C_lab2_NNs/Hand_Digit_with_NN_student.ipynb".
The first task is:
<font color='teal'> 3. Multi Class Classification </font>
In this section we will train classification schemes that allow us to discriminate between the 10 digits that make up the complete dataset. In this case, you must use the parameters provided, and you will be asked to study the execution times required by the different methods. To do this, you can use the time library as follows:
```
import time
start = time.time()
Some code should go here
etime = time.time() - start
````
3.1. Principal Component Analysis (PCA)
In a preliminary way, and as you did in section 2.2.1, we can analyze the first two PCA components of the available data. You can see that in this case there is a very important overlap between the digits of all the classes on the first two components of PCA.
In this section, we will apply the different classification strategies using all the available features.
Exercise 3.1: Analyze the variance of the successive projections that the PCA method would obtain, and reflect on whether a smaller-dimensional representation of the input data could be used.
Can you write Python code for it?

from sklearn.decomposition import PCA

pca = PCA(2)  # project from 784 to 2 dimensions
projected = pca.fit_transform(X_tr)
plt.scatter(projected[:, 0], projected[:, 1],
            c=y_tr, edgecolor='none', alpha=0.5,
            cmap=plt.cm.get_cmap('rainbow', 10))
plt.xlabel('component 1')
plt.ylabel('component 2')
plt.colorbar();

# Solution to Exercise 3.1

# <SOL>
# </SOL>


I am working on the file "C_lab2_NNs/Hand_Digit_with_NN_student.ipynb".
The first task is:
<font color='teal'> 5. Feed Forward Networks using PyTorch </font>
In this section we are going to illustrate how we can implement a multilayer perceptron-type neural network using the features of PyTorch. The network thus implemented will be equivalent to the one you would train using the scikit-learn MLP function, but thanks to the use of PyTorch it will be able to be executed parallelizing many of the calculations in GPU, which will allow a much faster training.
A first possibility would be the direct implementation of the neural network, through an implementation based on PyTorch tensors of the evaluation functions of the neural network and of the derivatives of the cost function with respect to the different parameters (back-propagation). However, PyTorch module nn provides different levels of abstraction that considerably simplify the implementation of the network, in addition to making the theoretical calculation of derivatives unnecessary.
Before proceding, we need to import training and test data as PyTorch tensors. The fragment below can be used for that purpose. Note that if you are using a GPU, all tensors should be moved to the GPU.
Exercise 5.1: Complete the code below to create PyTorch tensors for the different MNIST variables. The tensors for the input data have already been created for you. For encoding class membership, you need to create y_tr and y_val using One-Hot-Encoding. You can easily do that using sklearn method LabelBinarizer.
Can you write Python code for it?

from sklearn.preprocessing import LabelBinarizer

#Convert to Torch tensors. Float type is required
X_tr_torch = torch.from_numpy(X_tr).float()
X_val_torch = torch.from_numpy(X_tst).float()
# <SOL>
# </SOL>


I am working on the file "C_lab2_NNs/Hand_Digit_with_NN_student.ipynb".
The first task is:
A relevant parameter for the training of logistic regression is the optimization method used to update the parameter vector $\bf w$. You can try other methods different from the lbfgs method which is the default selection. You can find information about these methods online, for instance in this stackoverflow entry: Logistic regression python solvers' definitions
2.1.3. Polynomial Logistic Regression
A strategy for the implementation of classifiers that provide non-linear boundaries consists of transforming the input variables. To this end, in this section we will use polynomial transformations, exploring different values of the degree of the built-in terms to try to optimize performance.
The proposed processing scheme for this section consists of the following steps:

Polynomial expansion of the input variables using the PolynomialFeatures method of scikit-learn
Scaling of all variables to zero mean and unit variance (StandardScaler method)
Logistic regression

The free parameters to be adjusted are, therefore, the degree of the polynomial transformation and the parameter $ C $ of the logistic regression.
Exercise 2.4: Validate parameters degree and C of the proposed classification scheme using a 5-fold validation. Allow for polynomial transformations of degree up to 6. A very convenient way to do this is to define a processing pipeline in scikit-learn, and use it together with GridSearchCV.
Note that both parameters should be validated together, i.e., all possible combinations need to be evaluated.
For the next two cells to work, you need to use the following variable names:

clf: Best classifier selected with 5 fold strategy. It needs to implement a clf.predict_proba method
CE_poly: Average Classification Error Rate of previous classifier calculated over the test data
NLL_poly: Negative log-lilelihood of previous classifier calculated over the test data
Can you write Python code for it?

from sklearn.model_selection import GridSearchCV
from sklearn.linear_model import LogisticRegression
from sklearn.pipeline import Pipeline
from sklearn.preprocessing import PolynomialFeatures
from sklearn.preprocessing import StandardScaler

# <SOL>
# </SOL>

print('CE of Polynomial Logistic Regression Classifier (%):', CE_poly)
print('NLL of Polynomial Logistic Regression Classifier:', NLL_poly)
print('Selected parameters:', clf.best_params_)

plot_proba_map(X_tr_2D, y_tr_bin, clf)


I am working on the file "C_lab2_NNs/Hand_Digit_with_NN_student.ipynb".
The first task is:
Comparing this figures to those for the conventional gradient descent method, we can extract a number of conclusions:

Convergence is radically faster when using SGD with minibatches. Note that just after the first epoch the error (both in terms of loss function and CE) is already smaller than that achieved with conventional gradient descent

In this case, the error in the validation set starts increasing slightly after a number of epochs. I.e., even for a linear classifier overfitting may occur given the high dimensionality of the input data

Note that the final classification error is much larger than that observed in Section 3; however keep in mind that the network we have just implemented is constrained to linear classification.

Exercise 5.2: Implement network training with other optimization methods. You can refer to the official documentation and select a couple of methods. You can also try to implement adaptive learning rates using torch.optim.lr_scheduler
5.3. Multi Layer networks using nn.Sequential
As we have seen, PyTorch simplifies considerably the implementation of neural network training, since we do not need to implement derivatives ourselves.
We can also make a simpler implementation of multilayer networks using nn.Sequential function. It returns directly a network with the requested topology, including parameters and forward evaluation method
For instance, the cell below defines a Network with two hidden layers with 200 and 100 units for the resolution of the MNIST multiclass problem. Relu activation is used at the output of the neurons of the hidden layers.
Can you write Python code for it?

my_MLP_net = nn.Sequential(
    nn.Linear(X_tr_torch.size()[1], 200),
    nn.ReLU(),
    nn.Linear(200,100),
    nn.ReLU(),
    nn.Linear(100,y_tr_torch.size()[1])
)


I am working on the file "C_lab2_NNs/Hand_Digit_with_NN_student.ipynb".
The first task is:
Each row of X contains a different digit. You can display the original images by realigning the dimensions of each row of X, as shown in the following example:
Can you write Python code for it?

pos = 1900

plt.imshow(X[pos,].reshape(28, 28)), plt.axis('off'), plt.show()
print('The label of element %s is "%s"' % (pos, y[pos]))


I am working on the file "C_lab2_NNs/Hand_Digit_with_NN_student.ipynb".
The first task is:
Exercise 4.1:

Initialize a tensor x as X_tr[0,315:325]
Compute output vector y applying a function of your choice to x
Compute scalar value z as the sum of all elements in y squared
Check that x.grad calculation is correct using the backward method
Try to run your cell multiple times to see if the calculation is still correct. If not, implement the necessary modifications so that you can run the cell multiple times, but the gradient does not change from run to run

Note: The backward method can only be run on scalar variables
Can you write Python code for it?

if torch.cuda.is_available():
    x = torch.from_numpy(X_tr[0,315:325]).to(device)
else:
    x = torch.from_numpy(X_tr[0,315:325])

# <SOL>
# </SOL>


I am working on the file "C_lab2_NNs/Hand_Digit_with_NN_student.ipynb".
The first task is:
Exercise 5.3: Train the MLP network we have just defined on the MNIST dataset using the following settings:
   * Loss function: nn.CrossEntropyLoss()
   * Optimization algorithm: optim.Adam() with learning rate 1e-4
   * Minibatch size: 256
   * Number of epochs: 100
Calculate the time required to train the network
Can you write Python code for it?

# <SOL>
# </SOL>

plt.figure(figsize=(14,5))
plt.subplot(1, 2, 1), plt.plot(loss_tr, 'b'), plt.plot(loss_val, 'r'), plt.legend(['train', 'val']), plt.title('Cross-entropy loss')
plt.subplot(1, 2, 2), plt.plot(100*CE_tr, 'b'), plt.plot(100*CE_val, 'r'), plt.legend(['train', 'val']), plt.title('Classification Error (%)')
plt.show()


I am working on the file "C_lab2_NNs/Hand_Digit_with_NN_student.ipynb".
The first task is:
Exercise 5.4: Modify your code so that network training is done using GPUs. Compare the training time when using CPU and GPU implementations.
Can you write Python code for it?

# Network, training and validation data should be moved to GPU.
# You can do that with .to(device) or .cuda() functions

my_MLP_cuda = nn.Sequential(
    nn.Linear(X_tr_torch.size()[1], 200),
    nn.ReLU(),
    nn.Linear(200,100),
    nn.ReLU(),
    nn.Linear(100,y_tr_torch.size()[1])
).cuda()

X_tr_cuda = X_tr_torch.to(device)
X_val_cuda = X_val_torch.to(device)
y_tr_cuda = y_tr_torch.to(device)
y_val_cuda = y_val_torch.to(device)

# Adapt training code
# <SOL>
# </SOL>

plt.figure(figsize=(14,5))
plt.subplot(1, 2, 1), plt.plot(loss_tr, 'b'), plt.plot(loss_val, 'r'), plt.legend(['train', 'val']), plt.title('Cross-entropy loss')
plt.subplot(1, 2, 2), plt.plot(100*CE_tr, 'b'), plt.plot(100*CE_val, 'r'), plt.legend(['train', 'val']), plt.title('Classification Error (%)')
plt.show()


I am working on the file "C_lab2_NNs/Hand_Digit_with_NN_student.ipynb".
The first task is:
In this notebook we will explore different strategies for solving a  classification problem consisting of determining the handwritten digit corresponding to a $ 28 \times 28 $ pixel image (MNIST dataset).

We will start by tackling a binary classification problem using different classification algorithms whose implementations are available in scikit-learn, including the multilayer perceptron as an example of a multilayer type neural network (multilayer perceptron, MLP).

Next, we will consider multiclass classification, and calculate the performance of the previous algorithms in this more challenging problem.

The last part of the notebook contains an introduction to PyTorch, one of the most widely used libraries for neural network training. We will review the basic concepts of Pytorch and the different modules that allow simplifying the implementation and optimization of neural networks, including the design of convolutional neural networks (CNNs) that represent a more powerful alternative than MLPs in image classification problems.

For faster executions you must run PyTorch code on GPU. For this, it is sufficient to use Gooble Colab by properly configuring the runtime environment.
 Part 1. Scikit-learn Methods
 1. Data Preparation
1.1. Data load
MNIST is a handwritten digit classification problem that includes 60,000 training patterns and 10,000 test patterns, with representations obtained from the digitization of the corresponding grayscale images and with $28\times 28$ pixel resolution.
The database can be downloaded from the OpenML repository using tools available from Scikit-learn. It is recommended that after a first download you make a local copy of the data to speed up future executions.
Can you write Python code for it?

from sklearn.datasets import fetch_openml
from sklearn.model_selection import train_test_split

# Load data from https://www.openml.org/d/554
X, y = fetch_openml("mnist_784", version=1, return_X_y=True, as_frame=False)
# Format data in y as integers
y = y.astype(np.int)

print('Size of Input Data Matrix:', X.shape)
print('Size of Label Vector:', y.shape)


I am working on the file "C_lab2_NNs/Hand_Digit_with_NN_student.ipynb".
The first task is:
The next cell visualizes the classification border and the probabilistic map of the selected classifier (clf)
Can you write Python code for it?

def plot_proba_map(X, y, clf):

    # param X: Input Data Matrix (Size (N,2))
    # param y: Targets (Size (N,))
    # param clf: a classifier implementing the predict_proba method

    if X.shape[1] != 2:
        print('Can only plot 2D probability maps')
    else:
        # Create a regtangular grid.
        x_min, x_max = X[:, 0].min(), X[:, 0].max()
        y_min, y_max = X[:, 1].min(), X[:, 1].max()
        dx = x_max - x_min
        dy = y_max - y_min
        h = dy /400
        xx, yy = np.meshgrid(np.arange(x_min - 0.1 * dx, x_max + 0.1 * dx, h),
                              np.arange(y_min - 0.1 * dx, y_max + 0.1 * dy, h))
        X_grid = np.array([xx.ravel(), yy.ravel()]).T

        # Compute the classifier output for all samples in the grid.
        pp = clf.predict_proba(X_grid)[:,1]
        pp = pp.reshape(xx.shape)

        plt.figure(figsize=(10,5))
        plt.subplot(1, 2, 1)
        CS = plt.contourf(xx, yy, pp, cmap=plt.cm.copper)
        plt.contour(CS, levels=[0.5], colors='m', linewidths=(3,))
        plt.subplot(1, 2, 2)
        CS = plt.contourf(xx, yy, pp, cmap=plt.cm.copper)
        plt.scatter(X[:, 0], X[:, 1], c=y, s=4, cmap='summer')
        plt.contour(CS, levels=[0.5], colors='m', linewidths=(3,))
        plt.show()

plot_proba_map(X_tr_2D, y_tr_bin, clf)


I am working on the file "CaaRexamples.ipynb".
The first task is:
All column heading come directly from the original raw text files.
Can you write Python code for it?

inside_df.head()

outside_df = cr.create_geospatial_df(outside_pickle)

outside_df.head()


I am working on the file "CaaRexamples.ipynb".
The first task is:
Function daily_data_points_by_id()
Shows count of daily observations for a DataFrame for an ID
Can you write Python code for it?

daily_data_240 = cr.daily_data_points_by_id(inside_df, id=240)

daily_data_240.head()

daily_data_240.columns = ['Temperature Readings (Count)']
daily_data_240.head()


I am working on the file "CaaRexamples.ipynb".
The first task is:
Function days_of_data_by_id()
Number of days with data per ID (in cycles data, IDs are assigned to thermostats)
Can you write Python code for it?

days_cycle_data_by_id = cr.days_of_data_by_id(cycles_df)

days_cycle_data_by_id[0:2]


I am working on the file "CaaRexamples.ipynb".
The first task is:
Function detect_columns() - summarize file content automatically (optional)
The output summarizes file contents, without requiring the user to open the files themselves.
Required: Before detect_columns(), pickle_from_file() and dict_from_file(), specify type of data with the auto keyword parameter and any of the arguments: 'cycles', 'inside', 'outside'
Can you write Python code for it?

kwargs['auto'] = 'cycles'

cr.detect_columns(cycles, **kwargs)


I am working on the file "CaaRexamples.ipynb".
The first task is:
Function df_select_datetime_range() selects a range based on either string-formatted datetimes or datetime.datetime values.
It can be applied whether or not df_select_ids() has been applied.
Can you write Python code for it?


I am working on the file "CaaRexamples.ipynb".
The first task is:
Function df_select_ids()
In this example, select records for a list of IDs instead of a single ID
Can you write Python code for it?


I am working on the file "CaaRexamples.ipynb".
The first task is:
Function pickle_from_file() - create file once to allow quick conversion to pandas and NumPy
Can you write Python code for it?

cycles_pickle = cr.pickle_from_file(cycles, **kwargs)


I am working on the file "CaaRexamples.ipynb".
The first task is:
Function random_record() - selects data observation for inspection
Can you write Python code for it?

random_inside = cr.random_record('TX_sensors.pickle', value_only=False)


I am working on the file "CaaRexamples.ipynb".
The first task is:
Ignore columns (optional) when creating pandas DataFrames and NumPy arrays (0-based positions or headings)
Can you write Python code for it?

kwargs['cols_to_ignore'] = [4, 5, 6]

cr.detect_columns(cycles, **kwargs)


I am working on the file "CaaRexamples.ipynb".
The first task is:
In this example, the value of 55 is an outdoor temperature.
Can you write Python code for it?


I am working on the file "CaaRexamples.ipynb".
The first task is:
Names of binary files from ct.pickle_from_file() are automatically created unless specified using the picklepath keyword argument.
For example: kwargs['picklepath'] = 'my_cycle_file.pickle' can be specified before executing.
Can you write Python code for it?

for f in [cycles_pickle, inside_pickle, outside_pickle]:
    print(f)


I am working on the file "CaaRexamples.ipynb".
The first task is:
Note that because the cycles DataFrame has one more column in the index for the cycle mode, the slice has an additional ':' between the sensor ID of 240 (in this case, the sensor is a thermostat) and the date range.
Can you write Python code for it?


I am working on the file "CaaRexamples.ipynb".
The first task is:
Optional parameters
Can you write Python code for it?

cycle_mode = 'Cool' # for selecting only particular operation modes

states = 'TX' # state or states, such as 'TX,CA[,ST]'

thermostats_file = 'thermostats.csv' # A metadata file is needed when 'states' parameter is used.
postal_file = 'us_postal_codes_clean.csv' # Needed when 'states' parameter is used.

# These files are both in the caar repository in the data folder to serve as examples.


I am working on the file "CaaRexamples.ipynb".
The first task is:
Outside temperatures at thermostat location
Can you write Python code for it?

outside_temps_240 = cr.df_select_ids(outside_df, location_id)

outside_temps_240 = cr.df_select_datetime_range(outside_temps_240, '2012-07-11 14:30:00', '2012-07-11 16:30:00')

outside_temps_240.head()


I am working on the file "CaaRexamples.ipynb".
The first task is:
Overview
This introduction to CaaR shows how delimited text files are converted into indexed time series.
The functionality applies to any text file with time stamped data observations (scalars or vectors).
A plot of a multi-dimensional time series (operating status for an air conditioner and indoor temperatuure) is shown, based on the output of a CaaR time series function.
With CaaR, text files only need to be read once in order to be converted into Python variables. The user can use the pickle_from_file() function to create a pickle file (binary) from a text file. CaaR can convert pickle files created this way into a pandas DataFrame at any time. This is significantly faster than reading raw text files into pandas directly.
CaaR offers functions for summarizing and analyzing the data, and can convert DataFrames into NumPy time series index arrays and data arrays.
To explore the capabilities in full, see the documentation at http://caar.readthedocs.org
Read original text files into key-value pairs (dicts)
The pickle_from_file() and dict_from_file() functions convert delimited text files (comma- or tab-delimited) into key-value pairs (Python dicts). If the data covers multiple states, the output may be restricted to a particular states or states (using a comma-separated set of state abbreviations).
See example .csv data files in the data folder at https://github.com/nickpowersys/caar
The use of the states parameter is optional, and depends on sensor and postal metadata files (examples are also in the data folder in the Github repository).
Raw data files
Each data file is handled independently.
This example shows each of the three types of data files CaaR can handle. If only one or two of these types of data are available, the other(s) is (are) not required.
The types are

cycle device operations
sensor data from a sensor or sensors
geospatial data identified by location instead of by sensor (such as weather from an external/API source)

The following are specific examples of the general categories described:
Can you write Python code for it?

cycles = 'cycles.csv'         # Cycling device operations (in this example, air conditioners)
inside_temps = 'inside.csv'   # Sensor data from sensors (in this case, building thermostats)
outside_temps = 'outside.csv' # Temperatures associated with locations instead of sensors


I am working on the file "CaaRexamples.ipynb".
The first task is:
Pure pandas approach
Can you write Python code for it?


I am working on the file "CaaRexamples.ipynb".
The first task is:
Selecting ID and slicing on date ranges (pure pandas approach)
Can you write Python code for it?


I am working on the file "CaaRexamples.ipynb".
The first task is:
The index for records containing sensor-type observations is based on an ID and a time stamp.
Can you write Python code for it?

random_inside # The value of the data observation is 75.


I am working on the file "CaaRexamples.ipynb".
The first task is:
The only difference between the dict_from_file() and pickle_from_file() functions is that pickle_from_file() creates a pickle file, which allows faster read access in later sessions than text files.
With both functions, the output can be an input to the DataFrame creation functions, which are described next.
Reading dicts into pandas DataFrames
Using the pickle file or dict (like cycles_dict above) as input, there is one function for each kind of data (for cycles, indoor temperatures, or outdoor temperatures) that creates a pandas DataFrame.
Can you write Python code for it?

cycles_pickle = 'TX_cycles.pickle'
inside_pickle = 'TX_sensors.pickle'
outside_pickle = 'TX_geospatial.pickle'

cycles_df = cr.create_cycles_df(cycles_pickle)

cycles_df.head()

inside_df = cr.create_sensors_df(inside_pickle)


I am working on the file "CaaRexamples.ipynb".
The first task is:
Thermostat operations and temperature - plot as time series
time_series_cycling_and_temps(), plot_cycles_xy and plot_temps_xy
The output of time_series_cycling_and_temps() is used as input to the plot_cycles_xy() and plot_temps_xy() functions.
Can you write Python code for it?

start = dt.datetime(2012, 7, 11, 11, 0)
end = dt.datetime(2012, 7, 11, 19, 0)
cycles_and_temps_240 = cr.cycling_and_obs_arrays(cycles_df=cycles_df, cycling_id=240, start=start, end=end,
                                                 sensors_df=inside_df, sensor_id=240, freq='1min')

cycles_x, cycles_y = cr.plot_cycles_xy(cycles_and_temps_240)
temps_x, temps_y = cr.plot_sensor_geo_xy(cycles_and_temps_240)

fig, ax1 = plt.subplots()

ax1.xaxis.set_major_formatter(mdates.DateFormatter('%H:%M:%S'))
ax1.set_ylim(60.0,80.0)
ax1.set_xlabel('Time')
ax1.set_ylabel('Degrees (F)')
ax1.plot(temps_x, temps_y, marker='o', color='r')
ax2 = ax1.twinx()
ax2.set_ylim(0.0, 1.)
ax2.set_ylabel('ON/OFF (1/0)')
ax2.set_yticks([1.0])
ax2.yaxis.grid(False)
ax2.plot(cycles_x, cycles_y)
fig.set_size_inches(8, 4.5)
plt.title('Thermostat Operation (ON/OFF) and Indoor Temperature')
plt.show() # Note: timestamps in underlying data are from polling processes that have up to a minute delay.


I am working on the file "CahierChapitre1PolyPythonEdu.ipynb".
The first task is:
# Exercice 1 : appliquer ses connaissances #
Rédigez un programme qui vous donne la solution de l'équation
                       2ax + b = C

pour a≠0
Can you write Python code for it?

# Pensez à faire une copie de ce Cahier avant de rédiger "File …… "Make a Copy" "
# Renommez le cahier avec votre nom.
# Utilisez ce champ de saisie pour rédiger votre programme puis le tester.


I am working on the file "CahierChapitre1PolyPythonEdu.ipynb".
The first task is:
De l'utilité du module lycee pour nos élèves ?
Le projet Pythonedu semble considérer qu'il faut mettre à disposition des élèves un module qui masque les fonctionnalités de python ...
Il me semble en tant que prof validé ISN que cette démarche est contre productive.
Que fait lycee ?
Il est lié à des librairies python qui doivent être installées pour qu'il puisse fonctionner.

import math
import tkinter as Tk
import tkinter.filedialog as tkf
import random as alea
import matplotlib.pyplot as repere
import numpy as np
import builtins
from scipy.stats import norm

Puis il crée des fonctions qui sont pour le moins peu utiles ou en tout cas pas nécessaires pour un élève même débutant. Voyons deux exemples, avec lycee et sans lycee, qui pourraient être utilisés.
Pour les besoins de la démonstration lycee.py est placé dans le même dossier que ce notebook sur la raspberryPi de Tremplin.
Can you write Python code for it?

from lycee import *

# version utilisant lycee
from lycee import *
x=demande('Entrez une valeur pour x = ')
y=demande('Entrez une valeur pour y = ')
x,y=x+y,x-y
print("x = ",x,"y = ",y)
x,y=x+y,x-y
print ("maintenant , x =",x,"et y =",y)

# version utilisant python
x = int(input("Entrez un entier x : "))
y = int(input("Entrez un entier y : "))
print("réaffectation de x ET y avec x,y = x+y,x-y ")
x,y=x+y,x-y
print("nouvelle valeur de x = ",x,"nouvelle valeur de y = ",y)
print("réaffectation de x ET y avec x,y = x+y,x-y")
x,y=x+y,x-y
print("Maintenant la valeur de x = ",x," et la valeur de y = ",y)


I am working on the file "CahierChapitre1PolyPythonEdu.ipynb".
The first task is:
Les variables peuvent être affectées par lot. On peut réaffecter les variables en même temps ou successivement.
Can you write Python code for it?

#affection de a et b
a,b=" ceci est une chaîne de caractères ",' ceci est une chaîne de caractères '
print(a,b)
f=a+b
print(f)
e,g=3,4
print(e," : ",g)
h,i=e+g,e-g
print(h," : ",i)


I am working on the file "CahierChapitre1PolyPythonEdu.ipynb".
The first task is:
la casse des caractères
Il est important de se souvenir que les instruction en python s'écrivent en minuscule.
Lorsque une variable contient des Majuscules il faut dans tout le programme conserver ces majuscules.
Les champs de code suivants montrent ce qui se produit quand on suit la règle puis lorsqu'on ne la suit pas.
Can you write Python code for it?

# utilisation de la casse dans les variables
CoefficientDirecteur=2
ordonneeAlOrigine=6
print ("y =",CoefficientDirecteur,"x +", ordonneeAlOrigine)

# non respect de la casse dans un nom de variable
CoefficientDirecteur=2
ordonneeAlOrigine=6
print ("y=",Coefficientdirecteur,"x +", ordonneeAlorigine)


I am working on the file "Cal1-introPython.ipynb".
The first task is:
3. Types de données
3.1 Scalaires et chaînes
La déclaration des variables est implicite ({integer, float, boolean, string), la syntaxe est très proche de celle de R mais il n'y a pas de type factor.
Can you write Python code for it?

a=3  # est un entier
b=1. # est un flottant
# Attention:
a/2  # a pour résultat 1.5 en Python 3.4
     # mais 1 en 2.7


I am working on the file "Cal1-introPython.ipynb".
The first task is:
3.2 Structures de base
Listes
Les listes permettent des combinaisons de types.
Attention, le premier élément d'une liste ou d'un tableau est indicé par 0, pas par 1.
Can you write Python code for it?

# exemples de listes
liste_A = [0,3,2,'hi']
liste_B = [0,3,2,4,5,6,1]
liste_C = [0,3,2,'hi',[1,2,3]]
# Elément d'une liste
liste_A[1]

liste_C[-1] #  dernier élément

liste_C[-1][0]

liste_C[-2]

liste_B[0:2] #  Sous-liste

liste_B[0:5:2]  # début:fin:pas

liste_B[::-1]

# Fonctions de listes
List=[3,2,4,1]
List.sort()
print(List)

List.append('hi')
print(List)

List.count(3)

List.extend([7,8,9])
print(List)

List.append([10,11,12])
print(List)


I am working on the file "Cal1-introPython.ipynb".
The first task is:
4.4 Modules et librairies
Modules
Un module contient plusieurs fonctions et commandes qui sont regroupées dans un fichier d'extension .py. Insérer un fichier vide de nom _init_.py dans chaque dossier et sous-dossier contenant un module à importer.  Un module est appelé par la commande import. Un module est considéré comme un script s'il contient des commandes. Lors de l'import d'un script, les commandes sont exécutées tandis que les fonctions sont seulement chargées.
Commencer par définir un module dans un fichier texte contenant les commandes suivantes.
def DitBonjour():
    print("Bonjour")
def DivBy2(x):
    return x/2
Sauver le fichier avec pour nom testM.py dans le répertoire courant.
Il est possible d'importer toutes les fonctions en une seule commande import.
Can you write Python code for it?

import testM
testM.DitBonjour()

print(testM.DivBy2(10))

from testM import *
DitBonjour()

print(DivBy2(10))


I am working on the file "Cal1-introPython.ipynb".
The first task is:
Fonctions de type array
Can you write Python code for it?

np.arange(5)

np.ones(3)

np.ones((3,4))

np.eye(3)

np.linspace(3, 7, 3)

np.mgrid[0:3,0:2]

D=np.diag([1,2,4,3])
print(D)
print(np.diag(D))

M=np.array([[10*n+m for n in range(3)]
for m in range(2)])
print(M)


I am working on the file "Cal1-introPython.ipynb".
The first task is:
Le module numpy.random fournit toute une liste de fonctions pour la génération de matrices aléatoires.
Can you write Python code for it?

from numpy import random
random.rand(4,2) #tirage uniforme

random.randn(4,2) #tirage selon la loi N(0,1)

v=random.randn(1000)
import matplotlib.pyplot as plt
h=plt.hist(v,20) # histogramme à 20 pas
show()

A=random.randn(64,64)
plt.imshow(A,interpolation="nearest")
plt.colorbar
plt.show()

# Sauver, écrire dans un fichier, lire un fichier
M=random.randn(10,10)
np.savetxt('data.csv',M,fmt='%2.2f',delimiter=',')
#au format propre à numpy : npy

np.save('data.npy',M)
np.load('data.npy')


I am working on the file "Cal1-introPython.ipynb".
The first task is:
Les fonctions genfromtxt, avetxt permettent de lire, écrire des fichiers textes par exemple au format .csv mais ces fonctionnalités sont plus largement abordées avec la librairie pandas.
Fonctions d'algèbre linéaire
Can you write Python code for it?

# Importation
import numpy as np
from scipy import linalg
A = np.array([[1,2],[3,4]])
linalg.inv(A)

linalg.det(A)

la,v = linalg.eig(A)
l1,l2 = la
# valeurs propres
print(l1, l2)

# 1er vecteur propre
print(v[:,0])

# SVD de A
U,s,V = linalg.svd(A)
print(s**2)

linalg.eig(np.dot(np.transpose(A),A))


I am working on the file "Cal1-introPython.ipynb".
The first task is:
Lors de son premier appel, un module est pré-compilé dans un fichier .pyc qui est utilisé pour les appels suivants. Attention, si le fichier a été modifié / corrigé, il a besoin d'être rechargé par la commande reload(name).
Une librairie (package) regroupe plusieurs modules dans différents sous-répertoires. Le chargement spécifique d'un des modules se fait en précisant le chemin.
import sound.effects.echo
5. Calcul scientifique
Voici trois des principales librairies indispensables au calcul scientifique. Deux autres librairies: pandas, scikit-learn, sont exposées en détail dans des calepins spécifiques.
5.1 Principales librairies ou packages
NumPy
Cette librairie définit le type de données array ainsi que les fonctions de calcul qui y sont associées. Il contient aussi quelques fonctions d'algèbre linéaire et statistiques.
Il n'est finalement utilisé que pour la définition du type array car les fonctions numériques sont beaucoup plus développées dans  SciPy.
Matplotlib
Celle-ci propose des fonctions de visualisation / graphs avec des commandes proches de celles de Matlab. Aussi connue sous le nom de pylab. La gallerie de cette librairie propose tout un ensemble d'exemples de graphiques avec le code Python pour les générer.
Can you write Python code for it?

# Importation
import numpy as np
from pylab import *
gaussian = lambda x: np.exp(-(0.5-x)**2/1.5)
x=np.arange(-2,2.5,0.01)
y=gaussian(x)
plot(x,y)
xlabel("x values")
ylabel("y values")
title("Gaussian function")
show()


I am working on the file "Cal1-introPython.ipynb".
The first task is:
Opérateurs de comparaison : ==, >, <, != de résultat booléen.
Can you write Python code for it?

# Comparaison
a==b

#  affichage et type des variables
type(a)

# Chaîne de caractère
a='bonjour '
b='le '
c='monde'
a+b+c


I am working on the file "Cal1-introPython.ipynb".
The first task is:
Quelques manipulations:
Can you write Python code for it?

np.r_[1:4,10,11]  # Concaténation en ligne

np.c_[1:4,11:14]  # Concaténation en colonne

np.c_[1:4,11:15]  # erreur

np.arange(6).reshape(3,2)

A=np.array([[1,2],[3,4]])
np.tile(A,(3,2)) # Répétition de la matrice A

A=np.array([[1,2],[3,4]])
B=np.array([[11,12],[13,14]])
#Concaténation en ligne
np.concatenate((A,B),axis=0)

# Equivalent à
np.vstack((A,B))

# Concaténation en colonne
np.concatenate((A,B),axis=1)

# Equivalent à
np.hstack((A,B))


I am working on the file "Cal1-introPython.ipynb".
The first task is:
SciPy
Cette librairie est un ensemble très complet de modules d'algèbre linéaire, statistiques et autres algorithmes numériques. Le site  de la documentation en fournit la liste.
5.2 Type Array
C'est de loin la structure de données la plus utilisée pour le calcul scientifique sous Python. Elle décrit des tableaux ou matrices multi-indices de dimension $ n = 1, 2, 3, \ldots , 40$. Tous les éléments sont de même type (booléen, entier, réel, complexe).
Il est possible de contrôler précisément le type d'un array, par exemple pour gagner  de la place en mémoire, en codant les entiers sur 8, 16, 32 ou 64 bits, de même pour les réels (float) ou les complexes.
Les tableaux ou tables de données (data frame), bases d'analyses statistiques et regroupant des objets de types différents  sont décrits avec la librairie pandas.
Définition du type array
Can you write Python code for it?

# Importation
import numpy as np
my_1D_array = np.array([4,3,2])
print(my_1D_array)

my_2D_array = np.array([[1,0,0],[0,2,0],[0,0,3]])
print(my_2D_array)

myList=[1,2,3]
my_array = np.array(myList)
print(my_array)

a=np.array([[0,1],[2,3],[4,5]])
a[2,1]

a[:,1]


I am working on the file "Cal1-introPython.ipynb".
The first task is:
Slicing
Can you write Python code for it?

v=np.array([1,2,3,4,5])
print(v)

v[1:4]

v[1:4:2]

v[::]

v[ : :2] # par pas de 2

v[ : 3]

v[3 :] # à partir de l'indice 3

v[-1] # dernier élément

v[-2 :] # deux derniers éléments

M=random.rand(4,3)
print(M)

ind=[1,2]
M[ind] # lignes d'indices 1 et 2

M[:,ind] # colonnes d'indices 1 et 2

M[[0,2],[1,2]] # renvoie M[0,1] et M[2,2]

M[np.ix_([0,2],[1,2])]

(M>0.5)

M[M>0.5]


I am working on the file "Cal1-introPython.ipynb".
The first task is:
Tests élémentaires de Statistique
Can you write Python code for it?

# Importation
import scipy.stats
rvs1 = scipy.stats.norm.rvs(loc=5, scale=10,size=500)
rvs2 = scipy.stats.norm.rvs(loc=5, scale=10,size=500)
rvs3 = scipy.stats.norm.rvs(loc=8, scale=10,size=500)
# t-test returns: t-statistic/two-tailed p-value
scipy.stats.ttest_ind(rvs1, rvs2)

scipy.stats.ttest_ind(rvs1, rvs3)

# Kolmogorov-Smirnov test
# returns: KS statistic / two-tailed p-value
scipy.stats.ks_2samp(rvs1, rvs2)

scipy.stats.ks_2samp(rvs1, rvs3)


I am working on the file "Cal2-PythonPandas.ipynb".
The first task is:
2.3 Index
Les index peuvent être définis par emboîtement et beaucoup d'autres fonctionnalités sur la gestion des index sont décrites par Mac Kinney (2013) (chapitre 5):
- append nouvel index par concaténation,
- diff différence ensembliste,
- intersection intersection ensembliste,
- union union ensembliste
- isin vrai si la valeur est dans la liste,
- delete suppression de l'index $i$,
- drop suppression d'une valeur d'index,
- is_monotonic vrai si les valeurs sont croissantes,
- is_unique vrai si toutes les valeurs sont différentes,
- nique tableau des valeurs uniques de l'index.
3 Lire écrire des tables de données
Pandas offre des outils efficaces pour lire écrire des fichiers selon différents formats (csv, texte, fixe, compressé, xml, html, hdf5) ou interagir avec des bases de données SQL, MongoDB, des APIs web. Ce document se contente de décrire les fonctions les plus utiles read_csv et read_table pour lire des fichiers textes et générer un objet de classe DataFrame.
En principe ces fonctions font appel à un code écrit en C dont très rapide à l'exécution sauf pour l'emploi de certaines options (skip\_footer, sep} autre qu'un seul caractère), à éviter, qui provoquent une exécution en Python (engine=Python).
La réciproque pour l'écriture est obtenue par les commandes data.to_csv ou _table avec des options similaires.
3.1 Syntaxe
L'exemple de base est donné pour lire un fichier au format .csv dont les valeurs sont séparées par des "," et dont la première ligne contient le nom des variables.
import pandas as pd
data=pd.read_csv("fichier.csv")
data=pd.read_table("fichier.csv", sep=",")
Il est important de connaître la liste des possibilités et options offertes par cette simple commande. Voici les principales ci-dessous et un lien à la liste complète.
- path chemin ou non du fichier ou URL.
- sep délimiteur comme \verb+ , ; | \t + ou \verb# \s+ #  pour un nombre variable d'espaces.
- header défaut 0, la première ligne contient le nom des variables; si None les noms sont générés ou définis par...
Can you write Python code for it?

# Importations
import pandas as pd
import numpy as np
# tester la lecture
# path=""
path='./'
df = pd.read_csv(path+'titanic-train.csv',nrows=5)
df

df.tail()

# tout lire
df = pd.read_csv(path+"titanic-train.csv")
df.head()

# Des variables sont inexploitables
# Choisir les colonnes utiles
df=pd.read_csv(path+"titanic-train.csv",
    usecols=[1,2,4,5,6,7,9,11],nrows=5)
df.head()


I am working on the file "Cal2-PythonPandas.ipynb".
The first task is:
3 Gérer une table de données
3.1 Discrétisation d'une variable quantitative
Pour la discrétisation d'une variable quantitative. Il est d'un bon usage de définir les bornes des classes à des quantiles, plutôt qu'également espacées, afin de construire des classes d'effectifs sensiblement égaux.  Ceci est obtenu par la fonction qcut. La fonction cut propose par défaut des bornes équi-réparties à moins de fournir une liste de ces bornes.
Can you write Python code for it?

df["AgeQ"]=pd.qcut(df.Age,3,labels=["Ag1","Ag2",
   "Ag3"])
df["PrixQ"]=pd.qcut(df.Prix,3,labels=["Pr1","Pr2",
   "Pr3"])
df["PrixQ"].describe()


I am working on the file "Cal2-PythonPandas.ipynb".
The first task is:
3.2 Modifier / regrouper des modalités
Le recodage des variables qualitatives ou renommage en clair des modalités est obtenu simplement.
Can you write Python code for it?

df["Surv"]=df["Surv"].cat.rename_categories(
    ["Vnon","Voui"])
df["Classe"]=df["Classe"].cat.rename_categories(
    ["Cl1","Cl2","Cl3"])
df["Genre"]=df["Genre"].cat.rename_categories(
    ["Gfem","Gmas"])
df["Port"]=df["Port"].cat.rename_categories(
    ["Pc","Pq","Ps"])

df.head()


I am working on the file "Cal2-PythonPandas.ipynb".
The first task is:
3.4 Permutation et tirage aléatoires
Permutation aléatoire:
Can you write Python code for it?

dfs = pd.DataFrame(np.arange(5 * 4).reshape(5, 4))
sampler = np.random.permutation(5)
sampler
dfs
dfs.take(sampler)


I am working on the file "Cal2-PythonPandas.ipynb".
The first task is:
3.6 Tri et rangs
Trier une table selon les valeurs d'une variable ou d'un index.
Can you write Python code for it?

frame = pd.DataFrame(np.arange(8).reshape((2,4)),
        index=["three", "one"],
        columns=["d", "a", "b", "c"])
frame.sort_index()

frame.sort_index(axis=1)

frame.sort_index(axis=1, ascending=False)

frame.sort_values(by="b")


I am working on the file "Cal2-PythonPandas.ipynb".
The first task is:
Attention aux types implicites des variables. Si, par exemple, une donnée manquante n'apparaît pas dans une colonne du 1er morceau mais dans le 2ème, cela peut engendrer un conflit de type. Expliciter systématiquement les types et noms des variables dans un dictionnaire en paramètre.
6.2 Utilisation d'une table HDF5
Can you write Python code for it?

# Ouverture du fichier
Archiv=pd.HDFStore("titan.h5")
# sélection de la table et affichage de l'entête
Archiv.select("df").head()


I am working on the file "Cal2-PythonPandas.ipynb".
The first task is:
Il est possible d'associer recodage et regroupement des modalités en définissant un dictionnaire de transformation.
Can you write Python code for it?

data = pd.DataFrame({"food":["bacon","pulled pork",
   "bacon", "Pastrami",
   "corned beef", "Bacon", "pastrami", "honey ham",
   "nova lox"],
   "ounces": [4, 3, 12, 6, 7.5, 8, 3, 5, 6]})
data

meat_to_animal = {
    "bacon": "pig",
    "pulled pork": "pig",
    "pastrami": "cow",
    "corned beef": "cow",
    "honey ham": "pig",
    "nova lox": "salmon"
}
# Eviter les mélanges de majuscules minuscules
# en mettant tout en minuscule
data["animal"] = data["food"].map(
    str.lower).map(meat_to_animal)
data

data["food"].map(lambda x: meat_to_animal[x.lower()])

dfs = pd.DataFrame({"key": ["b", "b", "a", "c",
    "a", "b"],"data1": range(6)})
pd.get_dummies(dfs["key"])


I am working on the file "Cal2-PythonPandas.ipynb".
The first task is:
La commande rank remplace les valeurs par leur rang dans l'ordre des lignes ou des colonnes.
Can you write Python code for it?


I am working on the file "Cal2-PythonPandas.ipynb".
The first task is:
La gestion des clefs manquantes est en option: entre autres, ne pas introduire de ligne (ci-dessus), insérer des valeurs manquantes ci-dessous.
Can you write Python code for it?

# valeurs manquantes
pd.merge(df1,df2,on="key", how="outer")


I am working on the file "Cal2-PythonPandas.ipynb".
The first task is:
Remarque: il est également possible de tout lire avant de laisser "tomber" les variable inexploitables. C'est le rôle de la commande:
df = df.drop(["Name", "Ticket", "Cabin"], axis=1)
3.3 Echantillonnage simple
Comme dans R, le type DataFrame de Python est chargé en mémoire. Si, malgré les options précédentes permettant de sélectionner, les colonnes, les types des variables... le fichier est encore trop gros, il reste possible, avant de chercher une configuration matérielle lourde et en première approximation, de tirer un échantillon aléatoire simple selon une distribution uniforme. Un tirage stratifié demanderait plus de travail. Cela suppose de connaître le nombre de ligne du fichier ou une valeur inférieure proche.
Can you write Python code for it?

# pour les données titanic:
N=891  # taille du fichier
n=200  # taille de l'échantillon
lin2skipe=[0] # ne pas lire la première ligne
# ne pas lire N-n lignes tirées aléatoirement
lin2skipe.extend(np.random.choice(np.arange(1,N+1),
    (N-n),replace=False))
df_small=pd.read_csv(path+"titanic-train.csv",
    skiprows=lin2skipe,header=None,
    usecols=[1,2,4,5,9,11],
    names=["Surv","Classe","Genre","Age",
         "Prix","Port"])
df_small


I am working on the file "Cal2-PythonPandas.ipynb".
The first task is:
Tirage aléatoire avec remplacement ou bootstrap ; celui sans remplacement est traité section 3.3.
Can you write Python code for it?

bag = np.array([5, 7, -1, 6, 4])
sampler = np.random.randint(0, len(bag), size=10)
draws = bag.take(sampler)
draws


I am working on the file "Cal3-PythonGraphes.ipynb".
The first task is:
2.10 Grille
With the grid method in the axis object, we can turn on and off grid lines. We can also customize the appearance of the grid lines using the same keyword arguments as the plot function:
Can you write Python code for it?

fig, axes = plt.subplots(1, 2, figsize=(10,3))

# default grid appearance
axes[0].plot(x, x**2, x, x**3, lw=2)
axes[0].grid(True)

# custom grid appearance
axes[1].plot(x, x**2, x, x**3, lw=2)
axes[1].grid(color='b', alpha=0.5, linestyle='dashed', linewidth=0.5)
show()


I am working on the file "Cal3-PythonGraphes.ipynb".
The first task is:
2.11 Double graphique
Sometimes it is useful to have dual x or y axes in a figure; for example, when plotting curves with different units together. Matplotlib supports this with the twinx and twiny functions:
Can you write Python code for it?

fig, ax1 = plt.subplots()

ax1.plot(x, x**2, lw=2, color="blue")
ax1.set_ylabel(r"area $(m^2)$", fontsize=18, color="blue")
for label in ax1.get_yticklabels():
    label.set_color("blue")

ax2 = ax1.twinx()
ax2.plot(x, x**3, lw=2, color="red")
ax2.set_ylabel(r"volume $(m^3)$", fontsize=18, color="red")
for label in ax2.get_yticklabels():
    label.set_color("red")
show()


I am working on the file "Cal3-PythonGraphes.ipynb".
The first task is:
2.12 Axes centrés
Can you write Python code for it?

fig, ax = plt.subplots()

ax.spines['right'].set_color('none')
ax.spines['top'].set_color('none')

ax.xaxis.set_ticks_position('bottom')
ax.spines['bottom'].set_position(('data',0)) # set position of x spine to x=0

ax.yaxis.set_ticks_position('left')
ax.spines['left'].set_position(('data',0))   # set position of y spine to y=0

xx = np.linspace(-0.75, 1., 100)
ax.plot(xx, xx**3);
show()


I am working on the file "Cal3-PythonGraphes.ipynb".
The first task is:
2.13 Autres graphes 2D
In addition to the regular plot method, there are a number of other functions for generating different kind of plots. See the matplotlib plot gallery for a complete list of available plot types: http://matplotlib.org/gallery.html. Some of the more useful ones are show below:
Can you write Python code for it?

n = np.array([0,1,2,3,4,5])

fig, axes = plt.subplots(1, 4, figsize=(12,3))

axes[0].scatter(xx, xx + 0.25*np.random.randn(len(xx)))
axes[0].set_title("scatter")

axes[1].step(n, n**2, lw=2)
axes[1].set_title("step")

axes[2].bar(n, n**2, align="center", width=0.5, alpha=0.5)
axes[2].set_title("bar")

axes[3].fill_between(x, x**2, x**3, color="green", alpha=0.5);
axes[3].set_title("fill_between");
show()

# polar plot using add_axes and polar projection
fig = plt.figure()
ax = fig.add_axes([0.0, 0.0, .6, .6], polar=True)
t = np.linspace(0, 2 * np.pi, 100)
ax.plot(t, t, color='blue', lw=3);
show()

# A histogram
n = np.random.randn(100000)
fig, axes = plt.subplots(1, 2, figsize=(12,4))

axes[0].hist(n)
axes[0].set_title("Default histogram")
axes[0].set_xlim((min(n), max(n)))

axes[1].hist(n, cumulative=True, bins=50)
axes[1].set_title("Cumulative detailed histogram")
axes[1].set_xlim((min(n), max(n)));
show()


I am working on the file "Cal3-PythonGraphes.ipynb".
The first task is:
2.15 Figures avec sous graphes
Axes can be added to a matplotlib Figure canvas manually using fig.add_axes or using a sub-figure layout manager such as subplots, subplot2grid, or gridspec:
subplots
Can you write Python code for it?

fig, ax = plt.subplots(2, 3)
fig.tight_layout()
show()


I am working on the file "Cal3-PythonGraphes.ipynb".
The first task is:
2.16 Graphes de contour
Colormaps and contour figures are useful for plotting functions of two variables. In most of these functions we will use a colormap to encode one dimension of the data. There are a number of predefined colormaps. It is relatively straightforward to define custom colormaps. For a list of pre-defined colormaps, see: http://www.scipy.org/Cookbook/Matplotlib/Show_colormaps
Can you write Python code for it?

alpha = 0.7
phi_ext = 2 * np.pi * 0.5

def flux_qubit_potential(phi_m, phi_p):
    return 2 + alpha - 2 * np.cos(phi_p) * np.cos(phi_m) - alpha * np.cos(phi_ext - 2*phi_p)

phi_m = np.linspace(0, 2*np.pi, 100)
phi_p = np.linspace(0, 2*np.pi, 100)
X,Y = np.meshgrid(phi_p, phi_m)
Z = flux_qubit_potential(X, Y).T


I am working on the file "Cal3-PythonGraphes.ipynb".
The first task is:
2.3 Sauver les figures
To save a figure to a file we can use the savefig method in the Figure class:
Can you write Python code for it?


I am working on the file "Cal3-PythonGraphes.ipynb".
The first task is:
2.5 Formattage des textes: LaTeX et fontes
The figure above is functional, but it does not (yet) satisfy the criteria for a figure used in a publication. First and foremost, we need to have LaTeX formatted text, and second, we need to be able to adjust the font size to appear right in a publication.
Matplotlib has great support for LaTeX. All we need to do is to use dollar signs encapsulate LaTeX in any text (legend, title, label, etc.). For example, "$y=x^3$".
But here we can run into a slightly subtle problem with LaTeX code and Python text strings. In LaTeX, we frequently use the backslash in commands, for example \alpha to produce the symbol $\alpha$. But the backslash already has a meaning in Python strings (the escape code character). To avoid Python messing up our latex code, we need to use "raw" text strings. Raw text strings are prepended with an 'r', like r"\alpha" or r'\alpha' instead of "\alpha" or '\alpha':
Can you write Python code for it?

fig, ax = plt.subplots()

ax.plot(x, x**2, label=r"$y = \alpha^2$")
ax.plot(x, x**3, label=r"$y = \alpha^3$")
ax.legend(loc=2) # upper left corner
ax.set_xlabel(r'$\alpha$', fontsize=18)
ax.set_ylabel(r'$y$', fontsize=18)
ax.set_title('title');
show()


I am working on the file "Cal3-PythonGraphes.ipynb".
The first task is:
2.6 Couleurs, largeur et types de lignes
Colors
With matplotlib, we can define the colors of lines and other graphical elements in a number of ways. First of all, we can use the MATLAB-like syntax where 'b' means blue, 'g' means green, etc. The MATLAB API for selecting line styles are also supported: where, for example, 'b.-' means a blue line with dots:
Can you write Python code for it?

# MATLAB style line color and style
ax.plot(x, x**2, 'b.-') # blue line with dots
ax.plot(x, x**3, 'g--') # green dashed line


I am working on the file "Cal3-PythonGraphes.ipynb".
The first task is:
2.7 Contrôle des axes
The appearance of the axes is an important aspect of a figure that we often need to modify to make a publication quality graphics. We need to be able to control where the ticks and labels are placed, modify the font size and possibly the labels used on the axes. In this section we will look at controling those properties in a matplotlib figure.
Plot range
The first thing we might want to configure is the ranges of the axes. We can do this using the set_ylim and set_xlim methods in the axis object, or axis('tight') for automatrically getting "tightly fitted" axes ranges:
Can you write Python code for it?

fig, axes = plt.subplots(1, 3, figsize=(12, 4))

axes[0].plot(x, x**2, x, x**3)
axes[0].set_title("default axes ranges")

axes[1].plot(x, x**2, x, x**3)
axes[1].axis('tight')
axes[1].set_title("tight axes")

axes[2].plot(x, x**2, x, x**3)
axes[2].set_ylim([0, 60])
axes[2].set_xlim([2, 5])
axes[2].set_title("custom axes range");
show()


I am working on the file "Cal3-PythonGraphes.ipynb".
The first task is:
2.8 Placement des échelles et libellés
We can explicitly determine where we want the axis ticks with set_xticks and set_yticks, which both take a list of values for where on the axis the ticks are to be placed. We can also use the set_xticklabels and set_yticklabels methods to provide a list of custom text labels for each tick location:
Can you write Python code for it?

fig, ax = plt.subplots(figsize=(10, 4))

ax.plot(x, x**2, x, x**3, lw=2)

ax.set_xticks([1, 2, 3, 4, 5])
ax.set_xticklabels([r'$\alpha$', r'$\beta$', r'$\gamma$', r'$\delta$', r'$\epsilon$'], fontsize=18)

yticks = [0, 50, 100, 150]
ax.set_yticks(yticks)
ax.set_yticklabels(["$%.1f$" % y for y in yticks], fontsize=18); # use LaTeX formatted labels
show()


I am working on the file "Cal3-PythonGraphes.ipynb".
The first task is:
2.9 Formattage des espaces sur les axes
Can you write Python code for it?

# distance between x and y axis and the numbers on the axes
matplotlib.rcParams['xtick.major.pad'] = 5
matplotlib.rcParams['ytick.major.pad'] = 5

fig, ax = plt.subplots(1, 1)

ax.plot(x, x**2, x, np.exp(x))
ax.set_yticks([0, 50, 100, 150])

ax.set_title("label and axis spacing")

# padding between axis label and axis numbers
ax.xaxis.labelpad = 5
ax.yaxis.labelpad = 5

ax.set_xlabel("x")
ax.set_ylabel("y");
show()

# restore defaults
matplotlib.rcParams['xtick.major.pad'] = 3
matplotlib.rcParams['ytick.major.pad'] = 3


I am working on the file "Cal3-PythonGraphes.ipynb".
The first task is:
3.1  Surface plots
Can you write Python code for it?

fig = plt.figure(figsize=(14,6))

# `ax` is a 3D-aware axis instance because of the projection='3d' keyword argument to add_subplot
ax = fig.add_subplot(1, 2, 1, projection='3d')

p = ax.plot_surface(X, Y, Z, rstride=4, cstride=4, linewidth=0)

# surface_plot with color grading and color bar
ax = fig.add_subplot(1, 2, 2, projection='3d')
p = ax.plot_surface(X, Y, Z, rstride=1, cstride=1, cmap=matplotlib.cm.coolwarm, linewidth=0, antialiased=False)
cb = fig.colorbar(p, shrink=0.5)
show()


I am working on the file "Cal3-PythonGraphes.ipynb".
The first task is:
Although a little bit more code is involved, the advantage is that we now have full control of where the plot axes are placed, and we can easily add more than one axis to the figure:
Can you write Python code for it?

fig = plt.figure()

axes1 = fig.add_axes([0.1, 0.1, 0.8, 0.8]) # main axes
axes2 = fig.add_axes([0.2, 0.5, 0.4, 0.3]) # inset axes

# main figure
axes1.plot(x, y, 'r')
axes1.set_xlabel('x')
axes1.set_ylabel('y')
axes1.set_title('title')

# insert
axes2.plot(y, x, 'g')
axes2.set_xlabel('y')
axes2.set_ylabel('x')
axes2.set_title('insert title');
show;


I am working on the file "Cal3-PythonGraphes.ipynb".
The first task is:
Axis position adjustments
Unfortunately, when saving figures the labels are sometimes clipped, and it can be necessary to adjust the positions of axes a little bit. This can be done using subplots_adjust:
Can you write Python code for it?

fig, ax = plt.subplots(1, 1)

ax.plot(x, x**2, x, np.exp(x))
ax.set_yticks([0, 50, 100, 150])

ax.set_title("title")
ax.set_xlabel("x")
ax.set_ylabel("y")

fig.subplots_adjust(left=0.15, right=.9, bottom=0.1, top=0.9);
show()


I am working on the file "Cal3-PythonGraphes.ipynb".
The first task is:
Cette API est limitée à des graphes rudimentaires. Les fonctionalités orientées objet de Matplotlib sont à privilégier pour des graphes plus élaborées.
2 Matplotlib orienté objet
2.1 Syntaxe de base
The main idea with object-oriented programming is to have objects that one can apply functions and actions on, and no object or program states should be global (such as the MATLAB-like API). The real advantage of this approach becomes apparent when more than one figure is created, or when a figure contains more than one subplot.
To use the object-oriented API we start out very much like in the previous example, but instead of creating a new global figure instance we store a reference to the newly created figure instance in the fig variable, and from it we create a new axis instance axes using the add_axes method in the Figure class instance fig:
Can you write Python code for it?

fig = plt.figure()

axes = fig.add_axes([0.1, 0.1, 0.8, 0.8]) # left, bottom, width, height (range 0 to 1)

axes.plot(x, y, 'r')

axes.set_xlabel('x')
axes.set_ylabel('y')
axes.set_title('title');
show()


I am working on the file "Cal3-PythonGraphes.ipynb".
The first task is:
Change the view angle
We can change the perspective of a 3D plot using the view_init method, which takes two arguments: elevation and azimuth angle (in degrees):
Can you write Python code for it?

fig = plt.figure(figsize=(12,6))

ax = fig.add_subplot(1,2,1, projection='3d')
ax.plot_surface(X, Y, Z, rstride=4, cstride=4, alpha=0.25)
ax.view_init(30, 45)

ax = fig.add_subplot(1,2,2, projection='3d')
ax.plot_surface(X, Y, Z, rstride=4, cstride=4, alpha=0.25)
ax.view_init(70, 30)

fig.tight_layout()
show()


I am working on the file "Cal3-PythonGraphes.ipynb".
The first task is:
Example élémentaire d'utilisation de l'API.
Can you write Python code for it?

x = np.linspace(0, 5, 10)
y = x ** 2

figure()
plot(x, y, 'r')
xlabel('x')
ylabel('y')
title('titre')
show()


I am working on the file "Cal3-PythonGraphes.ipynb".
The first task is:
If we don't care about being explicit about where our plot axes are placed in the figure canvas, then we can use one of the many axis layout managers in matplotlib. My favorite is subplots, which can be used like this:
Can you write Python code for it?

fig, axes = plt.subplots()

axes.plot(x, y, 'r')
axes.set_xlabel('x')
axes.set_ylabel('y')
axes.set_title('title');
show()

fig, axes = plt.subplots(nrows=1, ncols=2)

for ax in axes:
    ax.plot(x, y, 'r')
    ax.set_xlabel('x')
    ax.set_ylabel('y')
    ax.set_title('title')
show()


I am working on the file "Cal3-PythonGraphes.ipynb".
The first task is:
La plupart des fonctions MATLAB sont incluses dans pylab.
Can you write Python code for it?


I am working on the file "Cal3-PythonGraphes.ipynb".
The first task is:
Line and marker styles
To change the line width, we can use the linewidth or lw keyword argument. The line style can be selected using the linestyle or ls keyword arguments:
Can you write Python code for it?

fig, ax = plt.subplots(figsize=(12,6))

ax.plot(x, x+1, color="blue", linewidth=0.25)
ax.plot(x, x+2, color="blue", linewidth=0.50)
ax.plot(x, x+3, color="blue", linewidth=1.00)
ax.plot(x, x+4, color="blue", linewidth=2.00)

# possible linestype options ‘-‘, ‘--’, ‘-.’, ‘:’, ‘steps’
ax.plot(x, x+5, color="red", lw=2, linestyle='-')
ax.plot(x, x+6, color="red", lw=2, ls='-.')
ax.plot(x, x+7, color="red", lw=2, ls=':')

# custom dash
line, = ax.plot(x, x+8, color="black", lw=1.50)
line.set_dashes([5, 10, 15, 10]) # format: line length, space length, ...

# possible marker symbols: marker = '+', 'o', '*', 's', ',', '.', '1', '2', '3', '4', ...
ax.plot(x, x+ 9, color="green", lw=2, ls='--', marker='+')
ax.plot(x, x+10, color="green", lw=2, ls='--', marker='o')
ax.plot(x, x+11, color="green", lw=2, ls='--', marker='s')
ax.plot(x, x+12, color="green", lw=2, ls='--', marker='1')

# marker size and color
ax.plot(x, x+13, color="purple", lw=1, ls='-', marker='o', markersize=2)
ax.plot(x, x+14, color="purple", lw=1, ls='-', marker='o', markersize=4)
ax.plot(x, x+15, color="purple", lw=1, ls='-', marker='o', markersize=8, markerfacecolor="red")
ax.plot(x, x+16, color="purple", lw=1, ls='-', marker='s', markersize=8,
        markerfacecolor="yellow", markeredgewidth=2, markeredgecolor="blue");
show()


I am working on the file "Cal3-PythonGraphes.ipynb".
The first task is:
Logarithmic scale
It is also possible to set a logarithmic scale for one or both axes. This functionality is in fact only one application of a more general transformation system in Matplotlib. Each of the axes' scales are set seperately using set_xscale and set_yscale methods which accept one parameter (with the value "log" in this case):
Can you write Python code for it?

fig, axes = plt.subplots(1, 2, figsize=(10,4))

axes[0].plot(x, x**2, x, np.exp(x))
axes[0].set_title("Normal scale")

axes[1].plot(x, x**2, x, np.exp(x))
axes[1].set_yscale("log")
axes[1].set_title("Logarithmic scale (y)");
show()


I am working on the file "Cal3-PythonGraphes.ipynb".
The first task is:
Légendes
Legends for curves in a figure can be added in two ways. One method is to use the legend method of the axis object and pass a list/tuple of legend texts for the previously defined curves:
Can you write Python code for it?


I am working on the file "Cal3-PythonGraphes.ipynb".
The first task is:
Or, alternatively, we can request that matplotlib uses LaTeX to render the text elements in the figure:
Can you write Python code for it?

matplotlib.rcParams.update({'font.size': 18, 'text.usetex': True})

fig, ax = plt.subplots()

ax.plot(x, x**2, label=r"$y = \alpha^2$")
ax.plot(x, x**3, label=r"$y = \alpha^3$")
ax.legend(loc=2) # upper left corner
ax.set_xlabel(r'$\alpha$')
ax.set_ylabel(r'$y$')
ax.set_title('title');
show()

# restore
matplotlib.rcParams.update({'font.size': 12, 'font.family': 'sans', 'text.usetex': False})


I am working on the file "Cal3-PythonGraphes.ipynb".
The first task is:
Ou importer le module matplotlib.pyplot avec l'identifiant plt. Plus correct pour éviter de charger tous les objets:
Can you write Python code for it?

# import matplotlib
import matplotlib.pyplot as plt

import numpy as np


I am working on the file "Cal3-PythonGraphes.ipynb".
The first task is:
The following figure shows how to use the figure title, axis labels and legends described above:
Can you write Python code for it?

fig, ax = plt.subplots()

ax.plot(x, x**2, label="y = x**2")
ax.plot(x, x**3, label="y = x**3")
ax.legend(loc=2); # upper left corner
ax.set_xlabel('x')
ax.set_ylabel('y')
ax.set_title('title');
show()


I am working on the file "Cal3-PythonGraphes.ipynb".
The first task is:
The method described above follows the MATLAB API. It is somewhat prone to errors and unflexible if curves are added to or removed from the figure (resulting in a wrongly labelled curve).
A better method is to use the label="label text" keyword argument when plots or other objects are added to the figure, and then using the legend method without arguments to add the legend to the figure:
Can you write Python code for it?

ax.plot(x, x**2, label="curve1")
ax.plot(x, x**3, label="curve2")
ax.legend();


I am working on the file "Cal3-PythonGraphes.ipynb".
The first task is:
The same arguments can also be passed to layout managers, such as the subplots function:
Can you write Python code for it?

fig, axes = plt.subplots(figsize=(12,3))

axes.plot(x, y, 'r')
axes.set_xlabel('x')
axes.set_ylabel('y')
axes.set_title('title');
show()


I am working on the file "Cal3-PythonGraphes.ipynb".
The first task is:
There are a number of more advanced methods for controlling major and minor tick placement in matplotlib figures, such as automatic placement according to different policies. See http://matplotlib.org/api/ticker_api.html for details.
Scientific notation
With large numbers on axes, it is often better use scientific notation:
Can you write Python code for it?

fig, ax = plt.subplots(1, 1)

ax.plot(x, x**2, x, np.exp(x))
ax.set_title("scientific notation")

ax.set_yticks([0, 50, 100, 150])

from matplotlib import ticker
formatter = ticker.ScalarFormatter(useMathText=True)
formatter.set_scientific(True)
formatter.set_powerlimits((-1,1))
ax.yaxis.set_major_formatter(formatter)
show()


I am working on the file "Cal3-PythonGraphes.ipynb".
The first task is:
We can also define colors by their names or RGB hex codes and optionally provide an alpha value using the color and alpha keyword arguments:
Can you write Python code for it?

fig, ax = plt.subplots()

ax.plot(x, x+1, color="red", alpha=0.5) # half-transparant red
ax.plot(x, x+2, color="#1155dd")        # RGB hex code for a bluish color
ax.plot(x, x+3, color="#15cc55")        # RGB hex code for a greenish color
show()


I am working on the file "Cal3-PythonGraphes.ipynb".
The first task is:
What formats are available and which ones should be used for best quality?
Matplotlib can generate high-quality output in a number formats, including PNG, JPG, EPS, SVG, PGF and PDF. For scientific papers, I recommend using PDF whenever possible. (LaTeX documents compiled with pdflatex can include PDFs using the includegraphics command). In some cases, PGF can also be good alternative.
2.4 Légendes, libellés et titres
Now that we have covered the basics of how to create a figure canvas and add axes instances to the canvas, let's look at how decorate a figure with titles, axis labels, and legends.
Titres
A title can be added to each axis instance in a figure. To set the title, use the set_title method in the axes instance:
Can you write Python code for it?


I am working on the file "Cal3-PythonGraphes.ipynb".
The first task is:
Wire-frame plot
Can you write Python code for it?

fig = plt.figure(figsize=(8,6))

ax = fig.add_subplot(1, 1, 1, projection='3d')

p = ax.plot_wireframe(X, Y, Z, rstride=4, cstride=4)
show()


I am working on the file "Cal3-PythonGraphes.ipynb".
The first task is:
add_axes
Manually adding axes with add_axes is useful for adding insets to figures:
Can you write Python code for it?

fig, ax = plt.subplots()

ax.plot(xx, xx**2, xx, xx**3)
fig.tight_layout()

# inset
inset_ax = fig.add_axes([0.2, 0.55, 0.35, 0.35]) # X, Y, width, height

inset_ax.plot(xx, xx**2, xx, xx**3)
inset_ax.set_title('zoom near origin')

# set axis range
inset_ax.set_xlim(-.2, .2)
inset_ax.set_ylim(-.005, .01)

# set axis tick locations
inset_ax.set_yticks([0, 0.005, 0.01])
inset_ax.set_xticks([-0.1,0,.1]);
show()


I am working on the file "Cal3-PythonGraphes.ipynb".
The first task is:
gridspec
Can you write Python code for it?

import matplotlib.gridspec as gridspec

fig = plt.figure()

gs = gridspec.GridSpec(2, 3, height_ratios=[2,1], width_ratios=[1,2,1])
for g in gs:
    ax = fig.add_subplot(g)

fig.tight_layout()
show()


I am working on the file "Cal3-PythonGraphes.ipynb".
The first task is:
imshow
Can you write Python code for it?

fig, ax = plt.subplots()

im = ax.imshow(Z, cmap=matplotlib.cm.RdBu, vmin=abs(Z).min(), vmax=abs(Z).max(), extent=[0, 1, 0, 1])
im.set_interpolation('bilinear')

cb = fig.colorbar(im, ax=ax)
show()


I am working on the file "Cal3-PythonGraphes.ipynb".
The first task is:
pcolor
Can you write Python code for it?

fig, ax = plt.subplots()

p = ax.pcolor(X/(2*np.pi), Y/(2*np.pi), Z, cmap=matplotlib.cm.RdBu, vmin=abs(Z).min(), vmax=abs(Z).max())
cb = fig.colorbar(p, ax=ax)
show()


I am working on the file "Cal4-PythonProg.ipynb".
The first task is:
1.3 Structures conditionnelles  if - else
L'instruction conditionelle if-else est une des plus communes en programmation informatique. En python, elle se présente sous la forme suivante:
if condition:

        instructions 1

 else:

        Instructions 2
Can you write Python code for it?

number=1
if number==1:
    print (True)
else:
    print (False)


I am working on the file "Cal4-PythonProg.ipynb".
The first task is:
2.1 filter
La fonction filter permet d'appliquer une fonction test à chaque valeur d'une liste. Si la fonction test est vérifiée, la valeur est ajoutée dans une nouvelle liste. Sinon, la valeur n'est pas prise en compte. La nouvelle liste, constitué de toutes les valeures "positive" selon la fonction test, est retournée.
Can you write Python code for it?

def is_odd(n):
    return n % 2 == 1
list(filter(is_odd,range(20)))


I am working on the file "Cal4-PythonProg.ipynb".
The first task is:
2.2 reduce
La dernière fonction est la fonction reduce. Cette approche est loin d'être intuitive. Le meilleur moyen de comprendre le mode d'emploi de cette fonction est d'utiliser un exemple.
L'objectif est de calculer la somme de tous les entier de 0 à 9.

Générer dans un premier temps la liste contenant tout ces éléments r10 = [0,1,2,3,4,5,6,7,8,9]
La fonction reduce, applique une première fois la fonction sum_and_print sur les deux premiers éléments de la liste.
Exécution récursive: la fonction sum_and_print est appliquée sur le résultat de la première opération et sur le 3ème éléments de la liste
Itération récursive jusqu'à ce que tous les éléments de la liste soient parcourus

La fonction reduce a donc deux arguments: une fonction et une liste.
Can you write Python code for it?

import functools
def sum_and_print(x,y):
    print("Input: ", x,y)
    print("Output: ", y)
    return x+y

r10 = range(10)
res =functools.reduce(sum_and_print, r10)
print(res)


I am working on the file "Cal4-PythonProg.ipynb".
The first task is:
2.4 lambda
L'utilisation de fonctions génériques permet de simplifier le code mais il est coûteux de définir une nouvelle fonction qui peut ne pas être réutilisée, comme par exemple celle de l'exemple précédent.
L'appel lambda permet de créer une fonction de façon temporaire. La définition de ces fonctions est assez restrictive, puisqu'elle implique une définition sur une seule ligne, et ne permet pas d'assignation.
Autre point important, l'exécution de cette fonction sur des données distribuées est implicitement parallélisée.
Ainsi les précédents exemples peuvent-être ré-écrits de la manière suivante:
Can you write Python code for it?

name=["Jason","bryan","hercule","Karim"]
list(map(lambda x : x[0].upper()+x[1:] if x[0].islower() else x,name))

list(filter(lambda x : x % 2 == 1 ,range(10)))

r10 = range(10)
res =functools.reduce(lambda x,y:x+y, r10,1000)
res


I am working on the file "Cal4-PythonProg.ipynb".
The first task is:
3 Classes et objets
3.1 Définitions et exemples
Les classes sont des objets communs à tous les langages orientés objets. Ce sont des objets constitués de

attributs: des paramètres fixes, de différentes natures, attribués à l'objet,
méthodes: des fonctions qui permettent d'appliquer des transformations sur ces attributs.

Ci dessous on définit une classe "Elève" dans laquelle un élève est décrit par son nom, son prénom et ses notes. On notera la convention de nommage des méthodes qui commence par une minuscule, mais qui possède une majuscule à chaque début de nouveau mot.
Can you write Python code for it?

class Eleve:
    """Classe définissant un élève caractérisé par:
        - son nom
        - son prénom
        - ses notes
     """

    def __init__(self, nom, prenom): #constructeur de la classe
        """ Construit un élève avec les nom et prenom passé en paramètre et une liste de notes vide."""
        self._nom = nom
        self._prenom=prenom
        self._notes = []

    def getNom(self):
        """ retourne le nom de l'élève """
        return self._nom

    def getNotes(self):
        """ retourne les notes de l'élève"""
        return self._notes

    def getNoteMax(self):
        """ retourne la note max de l'élève"""
        return max(self._notes)

    def getMean(self):
        """ retourne la moyenne de l'élève"""
        return np.mean(self._notes)

    def getNbNote(self):
        """ retourne le nombre de note de l'élève"""
        return len(self._notes)

    def addNote(self, note):
        """ ajoute la note 'note' à la liste de note de l'élève"""
        self._notes.append(note)


I am working on the file "Cal4-PythonProg.ipynb".
The first task is:
3.2 Héritage
L'héritage est une fonctionnalité qui permet de définir une classe "fille" à  partir d'une autre classe "mère". La classe fille hérite alors  automatiquement de tous les attributs et de toutes les méthodes de la classe mère.
Can you write Python code for it?

class EleveSpecial(Eleve):

    def __init__(self, nom, prenom, optionName):
        Eleve.__init__(self, nom, prenom)
        self._optionName = optionName
        self._optionNotes = []

    def getNotesOption(self):
        """ retourne les notes de l'élève"""
        return self._optionNotes

    def addNoteOption(self, note):
        """ ajoute la note 'note' à la liste de note de l'élève"""
        self._optionNotes.append(note)

eleve2 = EleveSpecial("Sam","Stress","latin")

eleve2.addNote(14)
print (eleve2.getNotes())
eleve2.addNoteOption(12)
print (eleve2.getNotesOption())


I am working on the file "Cal4-PythonProg.ipynb".
The first task is:
3.3 Classes de  Scikit-learn
Les méthodes d'apprentissage statistique de la librairie Scikit-learn sont un parfait exemple d'utilisation de classes. Sans entrer en détail dans l'implémentation de cette méthode, voici l'exemple de la Régression linéaire par moindres carrés.
Toutes les fonctions de Scikit-learn sont définies sur de modèle. Voir dans le tutoriel d'apprentissage statistique avec Scikit-learn comment ces propriétés sont utilisées pour enchaîner (pipeline) des exécutions.
L'objet LinearRegression est une classe qui est initée avec des attributs suivants:

fit_intercept : si le terme constant doit être estimé ou considéré à 0
normalize : si le jeux d'apprentissage doit être normalisé avant la regression
copy_X : si le jeux d'apprentissage doit être copié pour éviter les effets de bords
n_jobs : le nombre de processeur à utiliser
Can you write Python code for it?

from sklearn.linear_model import LinearRegression
lr = LinearRegression(fit_intercept=True, normalize=False, copy_X=True, n_jobs=1)
print (lr.fit_intercept, lr.normalize, lr.copy_X, lr.n_jobs)


I am working on the file "Cal4-PythonProg.ipynb".
The first task is:
4.2 Packing
Ces opérateurs sont surtout utiles dans le sens du "packing". Les fonctions sont alors définies de sorte à recevoir un nombre inconnu d'argument qui seront ensuite "paquétés" et traités dans la fonction.
L'argument *args permet à la fonction de recevoir un nombre supplémentaire inconnu d'arguments sans mot-clef associé.
Can you write Python code for it?

def packing_and_print_args(required_arg, *args):
    print ("arg Nécessaire:", required_arg)
    for i, arg in enumerate(args):
        print ("args %d:" %i, arg)

packing_and_print_args(1, "two", 3)
packing_and_print_args(1, "two", [1,2,3],{"a":1,"b":2,"c":3})


I am working on the file "Cal4-PythonProg.ipynb".
The first task is:
Affectation des indices
Des expressions telles que x = x + 1 ou x = x - 2 apparaissent très souvent dans le corps des boucles. Le language Python permet de simplifier ces notations.
Can you write Python code for it?

a = 17
s = "hi"
a += 3           # Equivalent to a = a + 3
a -= 3           # Equivalent to a = a - 3
a *= 3           # Equivalent to a = a * 3
a /= 3           # Equivalent to a = a / 3
a %= 3           # Equivalent to a = a % 3
s += " there"    # Equivalent to s = s + “ there"


I am working on the file "Cal4-PythonProg.ipynb".
The first task is:
Ces deux opérateurs sont très utiles pour gérer des classes liées par des héritages. Les arguments *args **kwargs permettent alors de gérer la tranmission de cet héritage sans avoir à redéfinir les arguments à chaque étape.
Can you write Python code for it?

class Objet(object):
    def __init__(self, attribut=None, *args, **kwargs):
        print (attribut)

class Objet2Point0(Objet):
    def __init__(self, *args, **kwargs):
        super(Objet, self).__init__(*args, **kwargs)

class Objet3Point0(Objet2Point0):
    def __init__(self,attribut2=None, *args, **kwargs):
        super(Objet2Point0, self).__init__(*args, **kwargs)
        print (attribut2)

my_data = {'attribut': 'Argument1', 'attribut2': 'Argument2'}
Objet3Point0(**my_data)


I am working on the file "Cal4-PythonProg.ipynb".
The first task is:
Dictionnaires
Un dictionnaire peut être parcouru terme à terme, cependant, comme la pluspart des objets python, les dictionnaires possèdent des fonctions permettant de les transformer en une liste:
.items()
.keys()
.values()

ou un iterator
.iteritems()
.iterkeys()
.itervalues()

Les dictionnaires n'ont pas de structure ordonnée, les valeurs ne s'affichent pas forcément dans l'ordre dans lequel on les a entrées.
Can you write Python code for it?

dico={"a":1,"b":2,"c":3}
for k in dico.keys():
    print (k)


I am working on the file "Cal4-PythonProg.ipynb".
The first task is:
L'appel à la fonction range(n) permet d'itérer sur les entiers de 0 à n-1 mais il est possible de spécifier des intervalles des valeurs de chaque pas d'itération: range(2,11,2) range(10,0,-1)
Strings
Les chaînes de caractères sont également des objets parcourables avec la boucle for: caractère après caractère.
Can you write Python code for it?

for character in "Hi There!":
    print (character)


I am working on the file "Cal4-PythonProg.ipynb".
The first task is:
L'instruction break permet de sortir de la boucle while même si sa condition est respectée.
Can you write Python code for it?

while True:
    number = int(input("Enter the numeric grade: "))
    if number >= 0 and number <= 100:
        break
    else:
        print ("Error: grade must be between 100 and 0" )
    print (number)


I am working on the file "Cal4-PythonProg.ipynb".
The first task is:
La classe LinearRegression possède aussi d'autres méthodes qui utilisent les attributs de la classe. Par exemple:

predict: estime la prévision de  la variable réponse d'un jeu test X_test
score: retourne le coefficient R2 de qualité de la prévision.
Can you write Python code for it?


I am working on the file "Cal4-PythonProg.ipynb".
The first task is:
La classe LinearRegression possède également des attributs qui sont mis à jour à l'aide des méthodes:

coef_ : coefficients estimés
residues_ : somme des résidus
intercept_ : terme constant

La méthode fit de cette classe est un mutator. Elle prend en paramètre le jeux d'apprentissage, X_train et la variable réponse correspondante Y_train pour estimer les paramètres de la regression linéaire et ainsi mettre à jour les attributs correspondants.
Can you write Python code for it?


I am working on the file "Cal4-PythonProg.ipynb".
The first task is:
Les arguments *args et **kwargs peuvent être combinés dans une autre fonctions.
Can you write Python code for it?

def packing_and_print_args_and_kwargs(required_arg ,def_kwarg=2, *args, **kwargs):
    print ("arg Nécessaire:", required_arg)
    for i, arg in enumerate(args):
        print ("args %d:" %i, arg)
    print ("kwarg défini:", def_kwarg)
    for i,(k,v) in enumerate(kwargs.items()):
        print ("kwarg %d:" %i ,k , v )

packing_and_print_args_and_kwargs(1, "two", [1,2,3] ,sup_arg1="two", sup_arg2=3 )


I am working on the file "Cal4-PythonProg.ipynb".
The first task is:
Les attributs de la classe sont directement accessibles de la manière suivante:
objet.nomDeLAtribbut
Cependant, par convention, il est conseillé de définir une méthode pour avoir accès à cet objet.
Les méthodes qui permettent d'accéder à des attributs de l'objets sont appelés des accessors. Dans la classe élève, les méthodes commençant par get sont des accessors.
Can you write Python code for it?


I am working on the file "Cal4-PythonProg.ipynb".
The first task is:
Les fonctions .items() et .iteritems() permettent de parcourir les couples (clés, objets) des dictionnaires.
Can you write Python code for it?

# Si une seule variable itérative est spécifiée, celle-ci est un-tuple.
for kv in dico.items():
    print (kv)

# Si deux variables itératives sont spécifiées, la première est la clé, la seconde la valeur correspondante
for k,v in dico.items():
    print (k)
    print (v)

# Si la clé ou la valeur du dictionnaire n'est pas nécessaire, elle n'est pas stockée dans une variable en utilisant "_"
for k,_ in dico.items():
    print (k)


I am working on the file "Cal4-PythonProg.ipynb".
The first task is:
Les méthodes permettant de modifier les attributs d'un objet sont appelées des mutators. La fonction addNote, qui permet d'ajouter une note à la liste de notes de l'élève est un mutator.
Can you write Python code for it?

print(eleve1.getNotes())
eleve1.addNote(15)
print(eleve1.getNotes())

for k in range(10):
    eleve1.addNote(np.random.randint(20))

print (eleve1.getNbNote())
print (eleve1.getNoteMax())
print (eleve1.getMean())


I am working on the file "Cal4-PythonProg.ipynb".
The first task is:
Librarie Itertools
La librairie native de python itertools possède de nombreuses fonctions générant des iterators.
Plus d'exemples dans la documentation.
Can you write Python code for it?

import itertools
#zip : Concatenne les éléments de plusieurs objets itérables
zip_list = []
for k in zip('ABCD',[1,2,3,4],"wxyz"):
    zip_list.append(k)
print("zip")
print(zip_list)

#permutation : retourne tous les arrangements possibles de liste de longueur n.
permutation_list = []
for k in itertools.permutations("ABCD",2):
    permutation_list.append(k)
print("permutations")
print(permutation_list)


I am working on the file "Cal4-PythonProg.ipynb".
The first task is:
Lorsque plus de deux alternative sont possibles, utiliser l'instruction elif pour énumérer les différentes possibilités.
Can you write Python code for it?

number=13
if number<5:
    print("A")
elif number <10:
    print("B")
elif number <20:
    print("C")
else:
    print("D")


I am working on the file "Cal4-PythonProg.ipynb".
The first task is:
Numpy Array
La fonction nditer permet de parcourir tous les éléments d'un tableau (array) Numpy.
Can you write Python code for it?

import numpy as np
a = np.arange(6).reshape(2,3)
for x in np.nditer(a):
    print (x)


I am working on the file "Cal4-PythonProg.ipynb".
The first task is:
One-Line Statement
Après avoir parouru différents éléments d'un objet itérable et pour enregistrer un résultat pour chaque étape dans une liste, il est possible d'écrire la boucle for sur une seule ligne de la manière suivante:
[result for variable in iterator]
Can you write Python code for it?

# Version1
A1=[]
for k in range(10):
    A1.append(k*k)

# Version 2
A2 = [k*k for k in range(10)]
print(A1,A2)


I am working on the file "Cal4-PythonProg.ipynb".
The first task is:
Pandas DataFrame
De la même manière que pour les arrays numpy, les DataFrame Pandas ne sont pas conçus pour être parcourus facilement. Il est, là encore, préférable d'utiliser au maximum les méthodes natives de pandas ou de numpy, ou de convertir au préalable les colonnes souhaitées en listes ou encore même de convertir un DataFrame en array avant un traitemnte itératif.
Il éxiste deux fonctions permettant de parcourir les différentes colonnes d'une DataFrame Pandas:

iterrows(): retourne le couple (index, ligne). Chaque ligne est parcourue sous la forme d'un objet Series de Pandas. Se construction est très coûteuse et rend la méthode très lente .
itertuples(): retoure un object specifique Pandas, où l'index, et les valeurs des colonnes de chaque ligne est accesible via des méthodes spécifiques. Plus rapide que iterrows.
Can you write Python code for it?

import pandas as pd
df = pd.DataFrame([["A",4],["B",5],["C",6]],index=[1,2,3],columns=["Letter","Number"])

for i,r in df.iterrows():
    print(i,r)

for ir in df.itertuples():
    print(ir)


I am working on the file "Cal4-PythonProg.ipynb".
The first task is:
Par défaut, la fonction passée en paramètre de la fonction reduce effectue sa première opérations sur les deux premiers éléments de la listes passés en paramètre. Mais il est possible de spécifier une valeur initiale en troisième paramètre. La première opération sera alors effectuée sur cette valeur initiale et le premier élément de la liste.
Can you write Python code for it?

def somme(x,y):
    return x+y

r10 = range(10)
res =functools.reduce(somme, r10,1000)
print(res)


I am working on the file "Cal4-PythonProg.ipynb".
The first task is:
Pour appliquer des fonctions plus complexes sur chaque ligne et/ou colonne de l'array, il existe également des fonctions natives de la librairie numpy permettant d'appliquer ces fonctions efficacement comme par exemple apply_along_axis, similaire à apply de R.
Can you write Python code for it?

def scale(x):
    xcr = (x-np.mean(x))/np.std(x)
    return xcr
X = np.random.randint(5, size=(3, 3))
Xcr = np.apply_along_axis(scale,1,X)
print(X, Xcr)


I am working on the file "Cal5-PythonSklearnApprent.ipynb".
The first task is:
2.2 Données "Titanic"
Les données sur le naufrage du Titanic sont décrites dans le calepin consacré à la librairie pandas. Reconstruire la table des données en lisant le fichier .csv.
Can you write Python code for it?

# Lire les données d'apprentissage
import pandas as pd
path=''  # si les données sont déjà dans le répertoire courant
# path='http://www.math.univ-toulouse.fr/~besse/Wikistat/data/'
df=pd.read_csv(path+'titanic-train.csv',skiprows=1,header=None,usecols=[1,2,4,5,9,11],
  names=["Surv","Classe","Genre","Age","Prix","Port"],dtype={"Surv":object,"Classe":object,"Genre":object,"Port":object})
df.head()

df.shape # dimensions
# Redéfinir les types
df["Surv"]=pd.Categorical(df["Surv"],ordered=False)
df["Classe"]=pd.Categorical(df["Classe"],ordered=False)
df["Genre"]=pd.Categorical(df["Genre"],ordered=False)
df["Port"]=pd.Categorical(df["Port"],ordered=False)
df.dtypes

df.count()

# imputation des valeurs manquantes
df["Age"]=df["Age"].fillna(df["Age"].median())
df.Port=df["Port"].fillna("S")

# Discrétiser les variables quantitatives
df["AgeQ"]=pd.qcut(df.Age,3,labels=["Ag1","Ag2","Ag3"])
df["PrixQ"]=pd.qcut(df.Prix,3,labels=["Pr1","Pr2","Pr3"])
# redéfinir les noms des modalités
df["Surv"]=df["Surv"].cat.rename_categories(["Vnon","Voui"])
df["Classe"]=df["Classe"].cat.rename_categories(["Cl1","Cl2","Cl3"])
df["Genre"]=df["Genre"].cat.rename_categories(["Gfem","Gmas"])
df["Port"]=df["Port"].cat.rename_categories(["Pc","Pq","Ps"])
df.head()


I am working on the file "Cal5-PythonSklearnApprent.ipynb".
The first task is:
5.2 Données "Titanic"
Même démarche.
Can you write Python code for it?

# définition des paramètres
forest = RandomForestClassifier(n_estimators=500, criterion='gini', max_depth=None,
    min_samples_split=2, min_samples_leaf=1, max_features='auto', max_leaf_nodes=None,bootstrap=True, oob_score=True)
# apprentissage
forest = forest.fit(T_train,z_train)
print(1-forest.oob_score_)

# erreur de prévision sur le test
1-forest.score(T_test,z_test)

# optimisation de max_features
param=[{"max_features":list(range(2,15))}]
titan_rf= GridSearchCV(RandomForestClassifier(n_estimators=100),param,cv=5,n_jobs=-1)
titan_rfOpt=titan_rf.fit(T_train, z_train)
# paramètre optimal
titan_rfOpt.best_params_

# erreur de prévision sur le test
1-titan_rfOpt.score(T_test,z_test)

# prévision
z_chap = titan_rfOpt.predict(T_test)
# matrice de confusion
table=pd.crosstab(z_test,z_chap)
print(table)


I am working on the file "Cal5-PythonSklearnApprent.ipynb".
The first task is:
6.4 Pipelines
Des transformations sont chaînées en une séquence constituant un pipeline.
Can you write Python code for it?

from sklearn.pipeline import make_pipeline
from sklearn.preprocessing import StandardScaler
from sklearn.feature_selection import RFE
#tf = RFE(RandomForestClassifier(), n_features_to_select=10)
# La succession de deux transformeurs constituent un transformeur
tf = make_pipeline(StandardScaler(), RFE(RandomForestClassifier(),n_features_to_select=10))
tf.fit(X_train, y_train)

Xt_train = tf.transform(X_train)
print("Mean =", np.mean(Xt_train))
print("Shape =", Xt_train.shape)


I am working on the file "Cal5-PythonSklearnApprent.ipynb".
The first task is:
6.5 Union de caractéristiques
Des transformations sont appliquées en parallèle pour réunir en un seul ensemble des transformations des données.
Can you write Python code for it?

from sklearn.pipeline import make_union
from sklearn.decomposition import PCA, FastICA
tf = make_union(PCA(n_components=10), FastICA(n_components=10))
Xt_train = tf.fit_transform(X_train)
print("Shape =", Xt_train.shape)


I am working on the file "Cal5-PythonSklearnApprent.ipynb".
The first task is:
Attention: l'échantillon test des données "Titanic" est relativement petit, l'estimation de l'erreur de prévision est donc sujette à caution car probablement de grande variance. Il suffit de changer l'initialisation (paramètre random_state) et ré-exécuter les scripts pour s'en assurer.
3 K plus proches voisins
Les images des caractères sont codées par des variables  quantitatives. Le problème de reconnaissance de forme ou de discrimination est adapté à l'algorithme des  $k$-plus proches voisins. Le paramètre à optimiser pour contrôler la complexité du modèle est le nombre de voisin n_neighbors. Les autres options sont décrites dans la documentation.
Can you write Python code for it?

from sklearn.neighbors import KNeighborsClassifier
knn = KNeighborsClassifier(n_neighbors=10)
digit_knn=knn.fit(X_train, y_train)
# Estimation de l'erreur de prévision
# sur l'échantillon test
1-digit_knn.score(X_test,y_test)


I am working on the file "Cal5-PythonSklearnApprent.ipynb".
The first task is:
Comme pour le modèle linéaire, il faudrait construire les commandes d'aide à l'interprétation des résultats.
Pénalisation et optimisation du paramètre par validation croisée. Il existe une fonction spécifique mais son mode d'emploi est peu documenté; GridSearchCV lui est préférée.
Can you write Python code for it?

# grille de valeurs
param=[{"C":[0.01,0.096,0.098,0.1,0.12,1,10]}]
logit = GridSearchCV(LogisticRegression(penalty="l1"),
   param,cv=5,n_jobs=-1)
titan_logitOpt=logit.fit(T_train, z_train)
# paramètre optimal
titan_logitOpt.best_params_["C"]


I am working on the file "Cal5-PythonSklearnApprent.ipynb".
The first task is:
Comme pour les autres méthodes, l'objet GridSearchCV ne contient pas tous les attibuts, dont celui tree, et ne permet pas de construire l'arbre. Il faudrait le ré-estimer mais comme il est bien trop complexe, ce résultat n'est pas produit.
5 Forêts aléatoires
L'algorithme d'agrégation de modèles le plus utilisé est celui des forêts aléatoires (random forest) de Breiman (2001) ce qui ne signifie pas qu'il conduit toujours à la meilleure prévision. Voir la documentation pour la signification de tous les paramètres.
Plus que le nombre d'arbres n_estimators, le paramètre à optimiser est le nombre de variables tirées aléatoirement pour la recherche de la division optimale d'un noeud: max_features. Par défaut, il prend la valeur $\frac{p}{3}$ en  régression et $\sqrt{p}$ en discrimination.
5.1 Données "Caractères"
Can you write Python code for it?

from sklearn.ensemble import RandomForestClassifier
# définition des paramètres
forest = RandomForestClassifier(n_estimators=500,
   criterion='gini', max_depth=None,
   min_samples_split=2, min_samples_leaf=1,
   max_features='auto', max_leaf_nodes=None,
   bootstrap=True, oob_score=True)
# apprentissage et erreur out-of-bag
forest = forest.fit(X_train,y_train)
print(1-forest.oob_score_)

# erreur de prévision sur le test
1-forest.score(X_test,y_test)


I am working on the file "Cal5-PythonSklearnApprent.ipynb".
The first task is:
Comme pour les autres méthodes, l'objet GridSearchCV ne propose pas tous les attributs et donc pas d'erreur out-of-bag ou d'importance des variables. Voir le tutoriel sur la prévision du pic d'ozone pour plus de détails.
Can you write Python code for it?

# erreur de prévision sur le test
1-digit_rfOpt.score(X_test,y_test)

# prévision
y_chap = digit_rfOpt.predict(X_test)
# matrice de confusion
table=pd.crosstab(y_test,y_chap)
print(table)
plt.matshow(table)
plt.title("Matrice de Confusion")
plt.colorbar()
plt.show()


I am working on the file "Cal5-PythonSklearnApprent.ipynb".
The first task is:
Commenter : parcimonie du modèle vs. erreur de prévision.
4 Arbre de décision
4.1 Implémentation
Les arbres binaires de décision (CART: classification and regression trees) s'appliquent à tous types de variables. Les options de l'algorithme sont décrites dans la documentation. La complexité du modèle est gérée par deux paramètres : max_depth, qui détermine le nombre max de feuilles dans l'arbre, et le nombre minimales min_samples_split d'observations requises pour rechercher une dichotomie.
Attention: Même s'il s'agit d'une implémentation proche de celle originale proposée par Breiman et al. (1984) il n'existe pas (encore?) comme dans R (package rpart) un paramètre de pénalisation de la déviance du modèle par sa complexité (nombre de feuilles) afin de construire une séquence d'arbres emboîtés dans la perspective d'un élagage (pruning) optimal par validation croisée. La fonction générique de $k$-fold cross validation GridSearchCV est utilisée pour optimiser le paramètre de profondeur mais sans beaucoup de précision dans l'élagage car ce dernier élimine tout un niveau et pas les seules feuilles inutiles à la qualité de la prévision.
En revanche, l'implémentation anticipe sur celles des méthodes d'agrégation de modèles en intégrant les paramètres (nombre de variables tirées, importance...) qui leurs sont spécifiques. D'autre part, la représentation graphique d'un arbre n'est pas incluse et nécessite l'implémentation d'un autre logiciel libre: Graphviz.
Tout ceci souligne encore les objectifs de développement de cette librairie: temps de calcul et prévision brute au détriment d'une recherche d'interprétation. Dans certains exemples éventuellement pas trop compliqués, un arbre élagué de façon optimal peut en effet prévoir à peine moins bien (différence non significative) qu'une agrégation de modèles (forêt aléatoire ou boosting) et apporter un éclairage nettement plus pertinent qu'un algorithme de type "boîte noire".
4.2 Données "Titanic"
Estimation de l'arbre complet.
Can you write Python code for it?

from sklearn.tree import DecisionTreeClassifier
tree=DecisionTreeClassifier()
digit_tree=tree.fit(T_train, z_train)
# Estimation de l'erreur de prévision
1-digit_tree.score(T_test,z_test)


I am working on the file "Cal5-PythonSklearnApprent.ipynb".
The first task is:
Décomposition, factorisation, réduction de dimension
Possibilité, par exemple, de récupérer les q premières composantes principales de l'ACP comme résultat d'une transformation.
Can you write Python code for it?

# par ACP ou SVD
from sklearn.decomposition import PCA
tf = PCA(n_components=2)
Xt_train = tf.fit_transform(X_train)