Hugging Face's logo

Spaces:
Dannel
/
dannel-name2gender
Configuration error

App Files Community
dannel-name2gender
File size: 8,282 Bytes 
51f2e05
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
 
# -*- coding: utf-8 -*-
"""
Archivo Python adaptado desde el notebook de databricks dispuesto desde el servicio de Azure-Data Sandbox
Created on Mon Dec 14 08:18:00 2020
@author: Carlos Delgado
"""

## Configrurando el storage account key


storage_account_name = "Storage Account"
storage_account_key = "Storage Account Key"
container = "Storage Account Source Container"
container_raw = "Storage Account Source Container Raw"

spark.conf.set("fs.azure.account.key.{0}.dfs.core.windows.net".format(storage_account_name), storage_account_key)
spark.conf.set("fs.azure.createRemoteFileSystemDuringInitialization", "true")
dbutils.fs.ls("abfss://{0}@{1}.dfs.core.windows.net/".format(container_raw, storage_account_name))
spark.conf.set("fs.azure.createRemoteFileSystemDuringInitialization", "false")


## Examinando el listado de archivos

dbutils.fs.ls("abfss://{0}@{1}.dfs.core.windows.net/OTROS/SNR/JSON/".format(container_raw, storage_account_name))
dbutils.fs.ls("abfss://{0}@{1}.dfs.core.windows.net/OTROS/KAGGLE/nombres_espanol_entrenamiento_test1/".format(container, storage_account_name))


## Importanto las principales librerias utilizadas en el algoritmo de predicci贸n

# Algoritmo adaptado de https://www.kaggle.com/migalpha/gender-predictor-by-spanish-names
#importando librerias iniciales
import pandas as pd
import numpy as np

#importando libreria de AI Scikit-learn
from sklearn.model_selection import train_test_split


## Obtencion de los datos iniciales desde el csv con spark

from pyspark.sql.functions import *
from pyspark.sql.types import *

df_fem_original = spark.read.csv("abfss://{0}@{1}.dfs.core.windows.net/OTROS/KAGGLE/nombres_espanol_entrenamiento_test1/female_names.csv".format(container, storage_account_name),header=True)
df_mal_original = spark.read.csv("abfss://{0}@{1}.dfs.core.windows.net/OTROS/KAGGLE/nombres_espanol_entrenamiento_test1/male_names.csv".format(container, storage_account_name),header=True)
display(df_fem_original)
display(df_mal_original)



## Migrando de Spark dataframes a Pandas dtaframes

#almacenando los nombres por genero a pandas dataframes
fem_nombres = df_fem_original.select("*").toPandas()
mal_nombres = df_mal_original.select("*").toPandas()


## Instanciando variables

#asignaci贸n de indicadores para genero, 0 femenino, 1 masculino
fem_nombres['genero'] = 0
mal_nombres['genero'] = 1


#unificaci贸n de conjunto de datos eliminando potenciales duplicados
data = fem_nombres.append(mal_nombres, ignore_index=True)
data = data.drop_duplicates(subset='name', keep=False)

#parceando y limpiando atributos innecesarios

target = data['genero'].astype(str)

del(data['frequency'])
del(data['mean_age'])
del(data['genero'])

features = data['name'].astype(str)


## Configurando el modelo del modelo

#se dividen los datos 80% entrenamiento - 20% testeo

X_train, X_test, y_train, y_test = train_test_split(features, target, random_state=7, test_size=0.2)
print(X_train.shape, X_test.shape, y_train.shape, y_test.shape)

#libreria para extraer caracteristicas de los archivos de texto
from sklearn.feature_extraction.text import CountVectorizer

#TF-IDF Esta librer铆a se encarga de transformar una matriz de conteo de ocurrencias (term-frequency)  a una matriz normalizada de ocurrencias ( term-frequency times inverse document-frequency)
#Mayor documentaci贸n tecnica en https://scikit-learn.org/stable/modules/generated/sklearn.feature_extraction.text.TfidfTransformer.html
from sklearn.feature_extraction.text import TfidfTransformer

#importando clasificador ML Naive Bayes NB
from sklearn.naive_bayes import MultinomialNB


#creando el pipeline
from sklearn.pipeline import Pipeline

text_classifier = Pipeline([('vect', CountVectorizer(ngram_range=(1,1))), ('tfidf',TfidfTransformer(norm='l2', sublinear_tf=True, use_idf=False)), ('clf', MultinomialNB(alpha=0.1))])


## Entrenamiento del modelo y calculo de accuracy

#entrenando el modelo
text_classifier = text_classifier.fit(X_train, y_train)

#calculando precisi贸n del modelo utilizando el clasificador NB
from sklearn.metrics import accuracy_score
predicted = text_classifier.predict(X_test)

print(accuracy_score(y_test, predicted))



## Testeando el modelo

#importando GridSearchCV para seleccionar los mejores hiperparametros
from sklearn.model_selection import GridSearchCV
parameters = {
        #'vect__max_df': (0.5, 0.625, 0.75, 0.875, 1.0),  
        #'vect__max_features': (None, 5000, 10000, 20000),  
        #'vect__min_df': (1, 5, 10, 20, 50),  
        'vect__ngram_range': [(1, 1), (1, 2)], 
        'tfidf__use_idf': (True, False),
        'tfidf__sublinear_tf': (True, False),  
        #'vect__binary': (True, False),  
        'tfidf__norm': ('l1', 'l2'),  
        'clf__alpha': (1, 0.1, 0.01, 0.001, 0.0001, 0.00001)
}

gs_classifier = GridSearchCV(text_classifier, parameters, n_jobs=-1, cv=2)
gs_classifier = gs_classifier.fit(X_train, y_train)

print(gs_classifier.best_score_)
print(gs_classifier.best_params_)


## Generaci贸n del punto de montaje

#testeando punto de montaje, el montaje se esta ejecutando satisfactoriamente

dbutils.fs.mount(
  source = "wasbs://{0}@{1}.blob.core.windows.net".format(container, storage_account_name),
  mount_point = "/mnt/auxiliar",
  extra_configs = {"fs.azure.account.key.{0}.blob.core.windows.net".format(storage_account_name):storage_account_key}
)


## Salvando el modelo como archivo de pickle .pkl


import pickle
from sklearn.externals import joblib
import tempfile
import os
from joblib import dump, load

#model_path = "/mnt/auxiliar/modelo_gender_pred.pkl"
s = pickle.dumps(text_classifier)
classifier2 = pickle.loads(s)
tmpFile = tempfile.NamedTemporaryFile(delete=False)
dump(text_classifier, tmpFile)
tmpFile.flush()
#print(clf2)

#copiando el modelo en pkl desde el punto de montaje al datalake
dump(classifier2, '/tmp/modelo_gender_pred.pkl') 
dbutils.fs.cp('file:/tmp/modelo_gender_pred.pkl', '/mnt/auxiliar/OTROS/KAGGLE/nombres_espanol_entrenamiento_test1/modelo_gender_pred_data_lake.pkl')

dbutils.fs.cp('/mnt/auxiliar/OTROS/KAGGLE/nombres_espanol_entrenamiento_test1/modelo_gender_pred_data_lake.pkl', '/tmp/modelo_gender_saved.pkl', )
display(dbutils.fs.ls ("/tmp/"))
classifier_Final = joblib.load('/dbfs/tmp/modelo_gender_saved.pkl')


#testeando algunas predicciones desde el modelo almacenado

print(classifier_Final.predict(("Valentina", )))
print(classifier_Final.predict(("Miguel", )))
print(classifier_Final.predict(("Maria", )))
print(classifier_Final.predict(("Joe", )))
print(classifier_Final.predict(("Santiago", )))
print(classifier_Final.predict(("Magdalena", )))


## Prediccion - Leyendo el archivo para prediccion

#leyendo el archivo desde el json del storage y alamcenandolo como pandas dataframe
dbutils.fs.ls("abfss://{0}@{1}.dfs.core.windows.net/OTROS/SNR/".format(container, storage_account_name))
#df_from_json = spark.read.json("abfss://{0}@{1}.dfs.core.windows.net/OTROS/SNR/nombres_apellido_nombre.json")
df_from_json = spark.read.json("abfss://{0}@{1}.dfs.core.windows.net/OTROS/SNR/nombres_para_clasificar.json".format(container, storage_account_name))



display(df_from_json)

df_to_predict = df_from_json.select("*").toPandas()
df_to_predict.head()


## Ejecutando la prediccion de los genereros

#Prediccion de los nuevos nombres que se le presentan al modelo
final_gender = []

#for item in df_to_predict.NOMBRES:
for item in df_to_predict.PRIMER_NOMBRE:
    #print("Nombre: %s ---- Genero: %s" %(item,clf.predict((item, ))))
    if pd.isnull(item) == True:
        final_gender.append("")
    elif clf.predict((item, ))[0] == '0':
        #print("Mujer")
        final_gender.append("MUJER")
    else:
        #print("Hombre")
        final_gender.append("HOMBRE")

#Campo donde se almacena la predicci贸n de los nombres        
df_to_predict['PREDICCION'] = final_gender

display(df_to_predict)


## Guardando los reusltados de la predicci贸n en CSV hacia el data lake

#df_to_predict.to_csv('/tmp/Prediccion_nombres_apellido_nombre.csv', index=False)
df_to_predict.to_csv('/tmp/Prediccion_nombres_para_clasificar.csv', index=False)
dbutils.fs.cp('file:/tmp/Prediccion_nombres_para_clasificar.csv', '/mnt/auxiliar/OTROS/KAGGLE/nombres_espanol_entrenamiento_test1/Prediccion_final_nombres_nombres_para_clasificar.csv')