<jupyter_start><jupyter_text>Echange de pétrole entre tous les pays du monde qu'elle a retravaillé pour qu'elle soit plus exploitable (enlever les valeurs manquantes etc.)Les liens sont orientés mais dans cet exercice, je ne veux que les liens rediriger. Je passe donc par pandas pour après le symétriser (en faisant la somme des directions).<jupyter_code>import pandas as pd
df=pd.read_csv('data/oilDB.csv',sep=',')
df.head()
# D'abord le graphique est dirigé.
dG=nx.from_pandas_edgelist(df,'exp','imp',['v'],create_using=nx.DiGraph())
# Je passe à un graphe non dirigé où le poids est la valeur des deux directions. 
G=nx.to_undirected(dG)
for (i,j) in G.edges():
    G[i][j]['weight']=0
    if (i,j) in dG.edges():
        #G[i][j]['weight']=G[i][j]['weight']+dG[i][j]['v']
        G[i][j]['weight']+= dG[i][j]['v'] #new (alain deboggage)
        G[j][i]['weight'] = G[i][j]['weight'] #new (alain deboggage)
    if (j,i) in dG.edges():
        #G[i][j]['weight']=G[i][j]['weight']+dG[j][i]['v']
        G[i][j]['weight']+= dG[j][i]['v'] #new
        G[j][i]['weight'] = G[i][j]['weight'] #new
list(G.edges(data=True))[:5]
nx.density(G)<jupyter_output><empty_output><jupyter_text>Weight's distribution<jupyter_code>def logBinning(degreeList,nbin):
    kmin=min(degreeList)
    kmax=max(degreeList)
    logBins = np.logspace(np.log10(kmin), np.log10(kmax),num=nbin)
    logBinDensity, binedges = np.histogram(degreeList, bins=logBins,density=True)
    logBins = np.delete(logBins, -1)
    return logBinDensity, logBins
weights=[G[u][v]['weight'] for (u,v) in G.edges()]
y,x=logBinning(np.array(weights),20)
plt.loglog(x,y,'o',markersize=10)
plt.xlabel('w')
plt.ylabel('P(w)')
plt.show()<jupyter_output><empty_output><jupyter_text>Strength distribution<jupyter_code>s=list(dict(G.degree(weight='weight')).values())
y,x=logBinning(np.array(s),10)
plt.loglog(x,y,'o',markersize=10)
plt.xlabel('s')
plt.ylabel('P(s)')
plt.show()<jupyter_output><empty_output><jupyter_text>Strength degree correlation Relation entre la force et le degré. La force grandit avec le degré ici comme attendu.<jupyter_code>k=list(dict(G.degree()).values())
plt.loglog(k,s,'o',alpha=0.3)

logBins=np.logspace(np.log2(np.min(k)),np.log2(np.max(k)),base=2,num=15)
ybin,xbin,binnumber=scipy.stats.binned_statistic(k,s,statistic='mean',bins=logBins)
plt.loglog(xbin[:-1],ybin,'o',markersize=10)

plt.xlabel('k')
plt.ylabel('s')
plt.show()<jupyter_output><empty_output><jupyter_text>Je cherche à faire un fit. Si c'est linéaire, il y a peu de degrés entre k et s sinon il y a une relations. Je fais donc comme avant ma loi de puissance logarithmique. Les pays qui ont du pétrole vont vendre plus que les autres c'est logique. La pondération est dans ce cas associée à la structure topologiqu.<jupyter_code>def powerLaw(x, a, b):
    return b*x**(a)
plt.loglog(k,s,'o',alpha=0.3)

#visualisation des données
logBins=np.logspace(np.log2(np.min(k)),np.log2(np.max(k)),base=2,num=15)
ybin,xbin,binnumber=scipy.stats.binned_statistic(k,s,statistic='mean',bins=logBins)
plt.loglog(xbin[:-1],ybin,'o',markersize=10)

#on fait le fit jusqu'à k=50 pour être sûr que ça marche bien 
fitx=[i for (i,j) in zip(k,s) if  i<50] #k jusqu'à 50
fity=[j for (i,j) in zip(k,s) if i<50]
popt, pcov = curve_fit(powerLaw, fitx, fity)  
#popt, pcov = curve_fit(powerLaw, k, s)  
print (popt[0])
plt.loglog(sorted(k), powerLaw(sorted(k), *popt), '--',c='k',linewidth=3)

plt.xlabel('k')
plt.ylabel('s')
plt.show()<jupyter_output>1.3063774614774446<jupyter_text>ROBUSTNESS Quelle est la robustesse du réseau ?   random failures On enlève (attaque) aléatoirement des noeuds. Je choisis la fraction que j'enlève 1/20 = 5/100 des noeuds.Alain dit qu'il faut faire 21 et pas 20<jupyter_code>fList=np.linspace(0,1,20)
NtoRem=[int(i*G.number_of_nodes()) for i in fList]
print(NtoRem)
On v
import random
sf=[]
for nn in NtoRem[:-1]:
    # je copie mon graphe pour ne pas toucher au graphe initial
    thisG=G.copy()
    # je prends un échantillon aléatoire de ces noeuds. 
    ll=random.sample(G.nodes(),nn)
    # je les enlève du graphe
    thisG.remove_nodes_from(ll)
    #je calcule la taille de la plus grande composante (maximale)
    thisSf=len(max(sorted(nx.connected_components(thisG), key = len, reverse=True)))
    # j'ajoute la taille/nb noeud dans la liste sf. 
    sf.append(thisSf/float(G.number_of_nodes()))
plt.plot(fList[:-1],sf,'o-',markerSize=10,label='random failure')
plt.xlabel('f')
plt.ylabel('Sf/N')
plt.legend()
plt.show()<jupyter_output>C:\Users\<NAME>\Anaconda3\lib\site-packages\ipykernel_launcher.py:1: MatplotlibDeprecationWarning: Case-insensitive properties were deprecated in 3.3 and support will be removed two minor releases later
  """Entry point for launching an IPython kernel.<jupyter_text>attacks Attaque ciblée : j'enlève les noeuds aux degrés les plus importants. Rq : Ce travail peut être fait avec un réseau dirigé. Ce serait mieux de le faire d'ailleurs sur un réseau dirigé.<jupyter_code>hh=collections.Counter(dict(G.degree())).most_common()
#je classe les noeuds selon leur degré.
orderedNodes=[u for (u,v) in hh]
#10 premiers noeuds
print(orderedNodes[:10])
fList1=np.linspace(0,1,20)
NtoRem=[int(i*G.number_of_nodes()) for i in fList1]
sfAtt=[]
for nn in NtoRem[:-1]:
    thisG=G.copy()
    # je prends les nn premiers dans le classement
    ll=orderedNodes[:nn]
    # je les enlève
    thisG.remove_nodes_from(ll)
    # je calcule la composante connectée
    thisSf=len(max(sorted(nx.connected_components(thisG), key = len, reverse=True)))
    sfAtt.append(thisSf/float(G.number_of_nodes()))
plt.plot(fList1[:-1],sfAtt,'o-',markerSize=10,label='attack')
plt.plot(fList[:-1],sf,'s-',markerSize=10,label='random failure')
plt.xlabel('f')
plt.ylabel('Sf/N')
plt.legend()
plt.show()<jupyter_output>C:\Users\<NAME>\Anaconda3\lib\site-packages\ipykernel_launcher.py:1: MatplotlibDeprecationWarning: Case-insensitive properties were deprecated in 3.3 and support will be removed two minor releases later
  """Entry point for launching an IPython kernel.
C:\Users\<NAME>\Anaconda3\lib\site-packages\ipykernel_launcher.py:2: MatplotlibDeprecationWarning: Case-insensitive properties were deprecated in 3.3 and support will be removed two minor releases later
{'fraction_non_alphanumeric': 0.1566960705693665, 'fraction_numerical': 0.01780272654370489, 'mean_word_length': 5.86028602860286, 'pattern_counts': {'":': 0, '<': 31, '<?xml version=': 0, '>': 29, 'https://': 0, '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': '7', 'dir': 'jupyter-structured-clean-dedup', 'id': '517120', 'license': 'MIT', 'n_tokens_mistral': 2563, 'n_tokens_neox': 2470, 'n_words': 545, 'path': 'CC4/exClasse/Seance4_ExerciseClasse3_KA.ipynb', 'repo_name': 'ARKEnsae/DM_Analyse_Reseaux', 'size': '6250'}