<jupyter_start><jupyter_text>De toutes les universités, quelles sont les meilleures ?<jupyter_code>import numpy as np # algèbre linéaire
import pandas as pd # procès de données, CSV file I/O (e.g. pd.read_csv)

# plotly
# import plotly.plotly as py
from plotly.offline import init_notebook_mode, iplot, plot
import plotly as py
init_notebook_mode(connected=True)
import plotly.graph_objs as go

# librairie word cloud
from wordcloud import WordCloud

# librairie matplotlib
import matplotlib.pyplot as plt

# Permet d'afficher les données disponibles dans le répertoire data
import os<jupyter_output><empty_output><jupyter_text>I. Chargement des données et explication des fonctionnalités<jupyter_code>timesData = pd.read_csv("https://simplonline-v3-prod.s3.eu-west-3.amazonaws.com/media/file/csv/be67fa74-2c34-419c-9249-050394a7eb3e.csv")
# Préparation des trames de données
df2014 = timesData[timesData.year == 2014].iloc[:10,:]
df2014
timesData.info()<jupyter_output><class 'pandas.core.frame.DataFrame'>
RangeIndex: 2603 entries, 0 to 2602
Data columns (total 14 columns):
 #   Column                  Non-Null Count  Dtype  
---  ------                  --------------  -----  
 0   world_rank              2603 non-null   object 
 1   university_name         2603 non-null   object 
 2   country                 2603 non-null   object 
 3   teaching                2603 non-null   float64
 4   international           2603 non-null   object 
 5   research                2603 non-null   float64
 6   citations               2603 non-null   float64
 7   income                  2603 non-null   object 
 8   total_score             2603 non-null   object 
 9   num_students            2544 non-null   object 
 10  student_staff_ratio     2544 non-null   float64
 11  international_students  2536 non-null   object 
 12  female_male_ratio       2370 non-null   object 
 13  year                    2603 non-null   int64  
dtypes: float64(4), int64(1), object(9)
memor[...]<jupyter_text>**timesData.csv** comprend 14 fonctionnalités qui sont:   * **world_rank** : classement mondial de l'université. Contient des plages de rangs et des rangs égaux (par exemple = 94 et 201-250)  * **university_name** : nom de l'université  * **country** : pays de chaque université  * **teaching** : score universitaire pour l'enseignement (l'environnement d'apprentissage)  * **international** : score universitaire des perspectives internationales (personnel, étudiants, recherche)  * **research** : score universitaire pour la recherche (volume, revenu et réputation)  * **citations** : score universitaire pour les citations (influence de la recherche)  * **income** : score universitaire pour le revenu de l'industrie (transfert de connaissances)  * **total_score** : score total pour l'université, utilisé pour déterminer le rang  * **num_students** : nombre d'étudiants à l'université  * **student_staff_ratio** : nombre d'étudiants divisé par le nombre d'employés  * **international_students** : Pourcentage d'étudiants internationaux  * **female_male_ratio** : Ratio étudiant féminin / étudiant masculin  * **year** : année du classement (2011 à 2016 inclus)<jupyter_code>pd.set_option('display.max_rows',75)
timesData.country.value_counts().sort_index(ascending=True)
timesData.country = timesData['country'].replace(['United Kingdom ','Unted Kingdom', 'United Kingdom'],'UK')
timesData['country'] = timesData['country'].replace(['Unisted States of America ','United States of America','Unisted States of America'],'USA')

timesData.country.value_counts().sort_index(ascending=True)<jupyter_output><empty_output><jupyter_text>1-Quels sont les pays dans lesquels le score universitaire pour le transfert de connaissances se démarque ? Utiliser un ou plusieurs graphique pour justifier votre réponse.    => South africa + Iran + Belguim + Netherland + South Korea ...<jupyter_code>dfValue = timesData
dfValue.income = pd.to_numeric(dfValue.income, errors='coerce')

ax = dfValue.groupby(['country']).income.mean().sort_values(ascending=False).plot(kind='bar', figsize = (18,5))
ax.set_xlabel('Pays', fontsize=14)
ax.set_title("Le score universitaire pour le transfert de connaissances par pays",fontsize=16)
ax.set_ylabel("Score moyen du revenu", fontsize=14)<jupyter_output><empty_output><jupyter_text>2-Existe-t-il une corrélation entre le score universitaire pour le transfert de connaissances et le score universitaire des perspectives internationales (personnel, étudiants, recherche) ? Utiliser un ou plusieurs graphique pour justifier votre réponse.        => Oui il existe bien une forte correlation entre les scores "income" et international, comme il le montre le graphique ci-dessous. Plus la moyenne des incomes par pays est grande plus la moyenne des international par pays est grande.<jupyter_code>import plotly.graph_objs as go

dfValue = timesData

timesData['international']=pd.to_numeric(timesData['international'], errors='coerce')


ax = dfValue.groupby('country').agg(np.mean).index
y1 = dfValue.groupby('country').income.agg(np.mean).sort_values(ascending=False)
y2 =  dfValue.groupby('country').international.mean().sort_values(ascending=False)

trace1 = {
  'x': ax,
  'y': y1, 
  'name': 'income',
  'type': 'bar'
};
trace2 = {
  'x': ax,
  'y': y2,
  'name': 'international',
  'type': 'bar'
};
data = [trace1, trace2];
layout = {
  'xaxis': {'title': 'Country'},
  'barmode': 'relative',
  'title': 'Correlation entre le score "income" et le score "international"'
};
fig = go.Figure(data = data, layout = layout)
iplot(fig)<jupyter_output><empty_output><jupyter_text>II. Analyse en composantes principales (PCA) ou (ACP)  l'analyse en composantes principales (ACP)est fondamentalement un algorithme de réduction de dimensionnalité, mais il peut également être utile comme outil de visualisation, d'extraction des variables. Les étapes de la Décomposation en PCA sont:- Standardiser les données.- Obtenez les vecteurs propres et les valeurs propres à partir de la matrice de covariance ou de la matrice de corrélation, ou effectuez une décomposition en valeurs singulières.- Triez les valeurs propres par ordre décroissant et choisissez les k vecteurs propres qui correspondent aux k plus grandes valeurs propres où k est le nombre de dimensions du nouveau sous-espace d'entités (k≤d).- Construire la matrice de projection W à partir des k vecteurs propres sélectionnés.- Transformez l'ensemble de données d'origine X via W pour obtenir un sous-espace d'entités à k dimensions Y.  II.1.Préparation des données:<jupyter_code>df=timesData
df2016 = df[df.year == 2016].iloc[:58,:]  # 8lines contains "NaN"
df2016 = df2016.dropna()
print(df2016.isnull().sum())
print(len(df2016))
df2016
def convertGender (x):
    a, b= x.split(':')
    c = int(a)/int(b)
    return c
df2016['female_male_ratio'] = df2016['female_male_ratio'].apply(convertGender)
df2016.world_rank = [int(each.replace('=','')) for each in df2016.world_rank]
df2016['international_students'] = df2016['international_students'].str.replace(r'%', r'.0').astype('float') / 100.0
df2016['num_students'] = df2016['num_students'].str.replace(r',', r'.').astype('float') 
df2016['income'] = df2016['income'].astype('float') 
df2016['international'] = df2016['international'].astype('float') 
df2016['total_score'] = df2016['total_score'].astype('float')<jupyter_output><empty_output><jupyter_text>II.2 PCA avec scikit-Learn<jupyter_code>df_2016 = df2016.drop(['year', 'university_name','country'], axis=1)
from sklearn.preprocessing import StandardScaler
#chargement de la première feuille de données
X = df_2016
sc = StandardScaler()
#transformation – centrage-réduction
Z = sc.fit_transform(X)

#dimension
print(Z.shape) # (50,11)
#nombre d'observations
n = Z.shape[0]
#nombre de variables
p = Z.shape[1]
#vérification 
#moyenne
print(np.mean(Z,axis=0))
#écart-type
print(np.std(Z,axis=0,ddof=0))
#classe pour l'ACP
from sklearn.decomposition import PCA
#instanciation
acp = PCA(svd_solver='full')
#calculs
coord = acp.fit_transform(Z)
#nombre de composantes calculées
print(acp.n_components_) # 11
#variance expliquée (ensemble des valeurs propres dans l'ordre décroissant)
val_prop = (n-1)/n*acp.explained_variance_
print(val_prop)
#scree plot
plt.plot(np.arange(1,p+1),val_prop)
plt.title("Scree plot")
plt.ylabel("Valeurs propres")
plt.xlabel("Factor number")
plt.grid()
plt.show()
#(correspond au pourcentage de variance de chaque ligne par rapport au total)
print(acp.explained_variance_ratio_)

#Le graphique du cumul de variance restituée selon le nombre de facteurs
#cumul de variance expliquée
plt.plot(np.arange(1,p+1),np.cumsum(acp.explained_variance_ratio_))
plt.title("Explained variance vs. # of factors")
plt.ylabel("Cumsum explained variance ratio")
plt.xlabel("Factor number")
plt.grid()
plt.show()<jupyter_output><empty_output><jupyter_text>II.2.1-Détermination du nombre de facteur à retenir Les ‘’cassures’’ dans les graphiques ci-dessus sont souvent évoquées pour identifier le nombre de facteurs K* à retenir.La valeur K* =5 permet de reteni plus de 90% des informations contenus dans les data d'originesLa valeur (K* = 2) est adéquate pour la vizualisation des dats dans le plan.Dans la suite on choisit K*=2<jupyter_code>from sklearn.decomposition import PCA
columns=X.columns.values #Store the name of the columns for labeling
pca=PCA(n_components=2)
pca.fit(Z)
pca_values=pca.components_
pca.components_ # les vecteurs propres stockées en ligne 
from sklearn import datasets
from sklearn.decomposition import PCA
import pandas as pd
import matplotlib.pyplot as plt

def pca_map(X, figsize=(10,10), sup="", print_values= False):
    #PCA
    columns=X.columns.values
    pca=PCA(n_components=2)
    pca.fit(X)
    pca_values=pca.components_
    
    #Plot
    plt.figure(figsize=figsize)
    plt.rcParams.update({'font.size': 14}) 
    
    #Plot circle
    x=np.linspace(start=-1,stop=1,num=500)
    y_positive=lambda x: np.sqrt(1-x**2) 
    y_negative=lambda x: -np.sqrt(1-x**2)
    plt.plot(x,list(map(y_positive, x)), color='maroon')
    plt.plot(x,list(map(y_negative, x)),color='maroon')
    
    #Plot smaller circle
    x=np.linspace(start=-0.5,stop=0.5,num=500)
    y_positive=lambda x: np.sqrt(0.5**2-x**2) 
    y_negative=lambda x: -np.sqrt(0.5**2-x**2)
    plt.plot(x,list(map(y_positive, x)), color='maroon')
    plt.plot(x,list(map(y_negative, x)),color='maroon')
    
    #Create broken lines
    x=np.linspace(start=-1,stop=1,num=30)
    plt.scatter(x,[0]*len(x), marker='_',color='maroon')
    plt.scatter([0]*len(x), x, marker='|',color='maroon')

    #Define color list
    colors = ['blue', 'red', 'green', 'black', 'purple', 'brown']
    if len(pca_values[0]) > 6:
        colors=colors*(int(len(pca_values[0])/6)+1)

    #Plot arrow
    add_string=""
    for i in range(len(pca_values[0])):
        xi=pca_values[0][i]
        yi=pca_values[1][i]
        plt.arrow(0,0, 
                  dx=xi, dy=yi, 
                  head_width=0.03, head_length=0.03, 
                  color=colors[i], length_includes_head=True)
        if print_values==True:
            add_string=f" ({round(xi,2)} {round(yi,2)})"
        plt.text(pca_values[0, i], 
                 pca_values[1, i] , 
                 s=columns[i] + add_string )

    plt.xlabel(f"Component 1 ({round(pca.explained_variance_ratio_[0]*100,2)}%)")
    plt.ylabel(f"Component 2 ({round(pca.explained_variance_ratio_[1]*100,2)}%)")
    plt.title('Variable factor map (PCA)')
    plt.suptitle(sup, y=1, fontsize=18)
    plt.show()
pca_map(X, figsize=(10,10), sup="data")<jupyter_output><empty_output>
{'fraction_non_alphanumeric': 0.12396408839779005, 'fraction_numerical': 0.03340814917127072, 'mean_word_length': 4.569711538461538, 'pattern_counts': {'":': 0, '<': 33, '<?xml version=': 0, '>': 36, 'https://': 1, 'lorem ipsum': 0, 'www.': 0, 'xml': 0}, 'pii_count': 0, 'substrings_counts': 0, 'word_list_counts': {'cursed_substrings.json': 0, 'profanity_word_list.json': 0, 'sexual_word_list.json': 0, 'zh_pornsignals.json': 0}}
{'chain_length': '8', 'dir': 'jupyter-structured-clean-dedup', 'id': '651698', 'license': 'MIT', 'n_tokens_mistral': 4255, 'n_tokens_neox': 3945, 'n_words': 1016, 'path': 'Rank_universities.ipynb', 'repo_name': 'bassembhiri/Universities-rank', 'size': '11584'}