<jupyter_start><jupyter_text>Notebook para limpiar datos y generar Features<jupyter_code>df_train = pd.read_csv('../data/train.csv')
df_test = pd.read_csv('../data/test.csv')
df_train.columns
print('Cantidad nulos en Titulo:', df_train.titulo.isnull().sum())
df_test.idzona.value_counts().nsmallest(9000)
print('Cantidad nulos en Descripcion:', df_train.descripcion.isnull().sum())
print('Cantidad nulos en Tipo Propiedad:', df_train.tipodepropiedad.isnull().sum())
df_train.tipodepropiedad.value_counts()
print('Cantidad nulos en Ciudad:', df_train.ciudad.isnull().sum())
df_train.ciudad.value_counts()
print('Cantidad nulos en Provincia:', df_train.provincia.isnull().sum())
df_train.provincia.value_counts()
print('Cantidad nulos en Habitaciones:', df_train.habitaciones.isnull().sum())
df_train.habitaciones.value_counts()
print('Cantidad nulos en Garages:', df_train.garages.isnull().sum())
df_train.garages.value_counts()
print('Cantidad nulos en Antiguedad:', df_train.antiguedad.isnull().sum())
df_train.antiguedad.value_counts()
print('Cantidad nulos en Baños:', df_train.banos.isnull().sum())
df_train.banos.value_counts()
print('Cantidad nulos en Metros Cubiertos:', df_train.metroscubiertos.isnull().sum())
df_train.metroscubiertos.value_counts()
print('Cantidad nulos en Metros Totales:', df_train.metrostotales.isnull().sum())
df_train.metrostotales.value_counts()
print('Cantidad nulos en Gimnasio:', df_train.gimnasio.isnull().sum())
df_train.gimnasio.value_counts()
print('Cantidad nulos en SUM:', df_train.usosmultiples.isnull().sum())
df_train.usosmultiples.value_counts()
print('Cantidad nulos en Piscina:', df_train.piscina.isnull().sum())
df_train.piscina.value_counts()
print('Cantidad nulos en Escuelas Cercanas:', df_train.escuelascercanas.isnull().sum())
df_train.escuelascercanas.value_counts()
print('Cantidad nulos en Centros Comerciales Cercanos:', df_train.centroscomercialescercanos.isnull().sum())
df_train.centroscomercialescercanos.value_counts()
print('Cantidad nulos en Fecha:', df_train.fecha.isnull().sum())
df_test.isnull().sum()<jupyter_output><empty_output><jupyter_text>-------------------------------------------------------------------------------------------------------------------------------------  Reemplazo de Nulos<jupyter_code># Imputamos los NaNs
df_train['metroscubiertos'] = imp_mean.fit_transform(df_train[['metroscubiertos']])
df_test['metroscubiertos'] = imp_mean.transform(df_test[['metroscubiertos']])
# Imputamos los NaNs
df_train['metrostotales'] = imp_mean.fit_transform(df_train[['metrostotales']])
df_test['metrostotales'] = imp_mean.transform(df_test[['metrostotales']])
# Imputamos los NaNs
df_train['banos'] = imp_mean.fit_transform(df_train[['banos']])
df_test['banos'] = imp_mean.transform(df_test[['banos']])
# Imputamos los NaNs
df_train['antiguedad'] = imp_mean.fit_transform(df_train[['antiguedad']])
df_test['antiguedad'] = imp_mean.transform(df_test[['antiguedad']])
# Imputamos los NaNs
df_train['garages'] = imp_mean.fit_transform(df_train[['garages']])
df_test['garages'] = imp_mean.transform(df_test[['garages']])
# Imputamos los NaNs
df_train['habitaciones'] = imp_mean.fit_transform(df_train[['habitaciones']])
df_test['habitaciones'] = imp_mean.transform(df_test[['habitaciones']])
# Imputamos los Nulos
df_train['tipodepropiedad'].fillna("Sin datos", inplace = True)
df_test['tipodepropiedad'].fillna("Sin datos", inplace = True)
# Imputamos los Nulos
df_train['ciudad'].fillna("Sin datos", inplace = True)
df_test['ciudad'].fillna("Sin datos", inplace = True)
# Imputamos los Nulos
df_train['provincia'].fillna("Sin datos", inplace = True)
df_test['provincia'].fillna("Sin datos", inplace = True)
# Imputamos los Nulos
df_train['descripcion'].fillna("Sin datos", inplace = True)
df_test['descripcion'].fillna("Sin datos", inplace = True)
# Imputamos los Nulos
df_train['titulo'].fillna("Sin datos", inplace = True)
df_test['titulo'].fillna("Sin datos", inplace = True)
# Imputamos los Nulos
df_train['direccion'].fillna("Sin datos", inplace = True)
df_test['direccion'].fillna("Sin datos", inplace = True)
# Elimino caracteres que pueden modificar palabras y llevo todas las palabras a minuscular
import string 
char_invalidos = string.punctuation

char_fin_linea = ['\n', '\t', '\r']

def limpiar_cadena (cadena):
    cadena_valida = cadena
    for un_char in char_invalidos:
        cadena_valida = cadena_valida.replace(un_char, " ")
        
    for un_char in char_fin_linea:
        cadena_valida = cadena_valida.replace(un_char, " ")
        
    return cadena_valida.lower()
df_train['descripcion'] = df_train['descripcion'].apply(limpiar_cadena)
df_test['descripcion'] = df_test['descripcion'].apply(limpiar_cadena)
df_train['titulo'] = df_train['titulo'].apply(limpiar_cadena)
df_test['titulo'] = df_test['titulo'].apply(limpiar_cadena)
df_train['direccion'] = df_train['direccion'].apply(limpiar_cadena)
df_test['direccion'] = df_test['direccion'].apply(limpiar_cadena)
'''df_combine = pd.concat([df_train, df_test])
id_zona_mode_by_ciudad = df_combine[~df_combine['idzona'].isnull()].groupby('ciudad').agg({'idzona': \
                                                               lambda x: x.mode()[0]}).T.to_dict('list')

def completar_zona_ciudad_combine (idzona, una_ciudad):
    if (np.isnan(idzona)):
        if (una_ciudad != "Sin datos"):
            if (una_ciudad in id_zona_mode_by_ciudad):
                return id_zona_mode_by_ciudad[una_ciudad][0]
    return idzona

df_train['idzona'] = df_train.idzona.combine(df_train.ciudad, func=completar_zona_ciudad_combine)
df_test['idzona'] = df_test.idzona.combine(df_test.ciudad, func=completar_zona_ciudad_combine)'''<jupyter_output><empty_output><jupyter_text>-------------------------------------------------------------------------------------------------------------------------------------  Creación de nuevos Features<jupyter_code>def relacion_entre_dos(numerador, denominador):
    if (denominador == 0):
        return 0
    return (numerador / denominador)<jupyter_output><empty_output><jupyter_text>Cantidad total de Amenities<jupyter_code>df_train['cantidad_amenities'] = df_train['gimnasio'] + df_train['usosmultiples'] + df_train['piscina']
df_test['cantidad_amenities'] = df_test['gimnasio'] + df_test['usosmultiples'] + df_test['piscina']<jupyter_output><empty_output><jupyter_text>Cantidad total de Servicios (escuales/comercios cercanos)<jupyter_code>df_train['cantidad_servicios'] = df_train['escuelascercanas'] + df_train['centroscomercialescercanos']
df_test['cantidad_servicios'] =  df_test['escuelascercanas'] + df_test['centroscomercialescercanos']<jupyter_output><empty_output><jupyter_text>Relación entre Metros Cubiertos sobre Metros Totales<jupyter_code>df_train['relacion_metros'] = df_train['metroscubiertos'] / df_train['metrostotales']
df_test['relacion_metros'] = df_test['metroscubiertos'] / df_test['metrostotales']<jupyter_output><empty_output><jupyter_text>Metros Cuadrados Cubiertos por Habitación<jupyter_code>df_train['metros_por_habitacion'] = df_train.metroscubiertos.combine(df_train.habitaciones, func=relacion_entre_dos)
df_test['metros_por_habitacion'] = df_test.metroscubiertos.combine(df_test.habitaciones, func=relacion_entre_dos)<jupyter_output><empty_output><jupyter_text>Metros cuadrados cubiertos por Baño<jupyter_code>df_train['metros_por_bano'] = df_train.metroscubiertos.combine(df_train.banos, func=relacion_entre_dos)
df_test['metros_por_bano'] = df_test.metroscubiertos.combine(df_test.banos, func=relacion_entre_dos)<jupyter_output><empty_output><jupyter_text>Metros cuadrados por cantidad total de Amenities<jupyter_code>df_train['metros_por_amenities'] = df_train.metroscubiertos.combine(df_train.cantidad_amenities, func=relacion_entre_dos)
df_test['metros_por_amenities'] = df_test.metroscubiertos.combine(df_test.cantidad_amenities, func=relacion_entre_dos)<jupyter_output><empty_output><jupyter_text>Cantidad de Baños por habitación<jupyter_code>df_train['bano_por_habitacion'] = df_train.banos.combine(df_train.habitaciones, func=relacion_entre_dos)
df_test['bano_por_habitacion'] = df_test.banos.combine(df_test.habitaciones, func=relacion_entre_dos)<jupyter_output><empty_output><jupyter_text>Cantidad de Garages por habitación<jupyter_code>df_train['garages_por_habitacion'] = df_train.garages.combine(df_train.habitaciones, func=relacion_entre_dos)
df_test['garages_por_habitacion'] = df_test.garages.combine(df_test.habitaciones, func=relacion_entre_dos)<jupyter_output><empty_output><jupyter_text>Precio promedio según provincia<jupyter_code>precio_promedio_por_provincia = df_train.groupby('provincia').agg({'precio':'mean'}).T.to_dict('list')

def obtener_precio_promedio_por_provincia(una_provincia):
    return precio_promedio_por_provincia[una_provincia][0]

#No sirve agregar feature de promedio provincial<jupyter_output><empty_output><jupyter_text>Precio promedio según la ciudad<jupyter_code>precio_promedio_por_ciudad = df_train.groupby('ciudad').agg({'precio':'mean', 'id': 'count',\
                                                             'provincia': lambda x: x.mode()[0]}).T.to_dict('list')
precio_promedio_general = df_train.precio.mean()
precio_promedio_por_ciudad
#SI LA CIUDAD TIENE MENOS DE 10 VALUES EN EL DF, SE HACE EL PROMEDIO PROVINCIAL
#SI LA CIUDAD NO TIENE PROMEDIO PROVINCIAL, SE HACE PROMEDIO GENERAL

def obtener_provincia(una_ciudad):
    return precio_promedio_por_ciudad[una_ciudad][2]

def obtener_precio_promedio_por_ciudad(una_ciudad):
    if una_ciudad in precio_promedio_por_ciudad:
        if precio_promedio_por_ciudad[una_ciudad][1] >= 10:
            return precio_promedio_por_ciudad[una_ciudad][0]
        return precio_promedio_por_provincia[obtener_provincia(una_ciudad)][0]
    return precio_promedio_general
df_train['precio_prom_ciudad'] = df_train['ciudad'].apply(obtener_precio_promedio_por_ciudad)
df_test['precio_prom_ciudad'] = df_test['ciudad'].apply(obtener_precio_promedio_por_ciudad)<jupyter_output><empty_output><jupyter_text>Precio promedio según tipo de propiedad<jupyter_code>precio_promedio_por_propiedad = df_train.groupby('tipodepropiedad').agg({'precio':'mean'}).T.to_dict('list')
precio_promedio_por_propiedad
def obtener_precio_promedio_por_propiedad(un_tipo_propiedad):
    if un_tipo_propiedad in precio_promedio_por_propiedad:
        return precio_promedio_por_propiedad[un_tipo_propiedad][0]
    return precio_promedio_general
df_train['precio_prom_propiedad'] = df_train['tipodepropiedad'].apply(obtener_precio_promedio_por_propiedad)
df_test['precio_prom_propiedad'] = df_test['tipodepropiedad'].apply(obtener_precio_promedio_por_propiedad)<jupyter_output><empty_output><jupyter_text>Precio según idzona<jupyter_code>precio_promedio_por_idzona = df_train.groupby('idzona').agg({'precio':'mean', 'id': 'count',\
                                                             'ciudad': lambda x: x.mode()[0]}).T.to_dict('list')
precio_promedio_por_idzona
#SI IDZONA TIENE MENOS DE 2 VALUES EN EL DF, SE HACE EL PROMEDIO DE LA CIUDAD
#SI IDZONA NO ESTA EN EL DICT, SE HACE PROMEDIO GENERAL

def obtener_ciudad(un_idzona):
    return precio_promedio_por_idzona[un_idzona][2]

def obtener_precio_promedio_por_idzona(un_idzona):
    if un_idzona in precio_promedio_por_idzona:
        if precio_promedio_por_idzona[un_idzona][1] >= 2:
            return precio_promedio_por_idzona[un_idzona][0]
        return precio_promedio_por_ciudad[obtener_ciudad(un_idzona)][0]
    return precio_promedio_general
df_train['precio_prom_idzona'] = df_train['idzona'].apply(obtener_precio_promedio_por_idzona)
df_test['precio_prom_idzona'] = df_test['idzona'].apply(obtener_precio_promedio_por_idzona)<jupyter_output><empty_output><jupyter_text>Pertenece al TOP5 de Provincias más caras<jupyter_code>TOP5_provincias_caras = ['Distrito Federal', 'Edo. de México', 'Nuevo León', 'Guerrero', 'Quintana Roo']

def es_provincia_top5 (ciudad):
    if (ciudad in TOP5_provincias_caras):
        return 1
    return 0
df_train['provincia_top5'] = df_train['provincia'].apply(es_provincia_top5)
df_test['provincia_top5'] = df_test['provincia'].apply(es_provincia_top5)<jupyter_output><empty_output><jupyter_text>Palabras en descripcion y titulo<jupyter_code>lst_palabras_seguridad = ['seguridad', 'seguro', 'tranquilidad', 'tranquilo', 'paz']
lst_palabras_moderno = ['modernas', 'modernos', 'moderna', 'moderno', 'modernidad']
lst_palabras_hermoso = ['hermoso', 'hermosa', 'hermosos', 'hermosas', 'lindo', 'linda', 'lindos', 'lindas', 'bello', 'bella', 'bellos', 'bellas']
lst_palabras_estado = ['excelente', 'excelentes', 'residencial', 'confort']
def contar_cantidad_palabras (cadena, lst_palabras_a_buscar):
    cantidad_palabras = 0
    for una_palabra in cadena.split():
        if una_palabra in lst_palabras_a_buscar:
            cantidad_palabras += 1
    return cantidad_palabras
# PALABRAS EN DESCRIPCION
df_train['seguridad_descripcion'] = df_train['descripcion'].apply(lambda x: contar_cantidad_palabras(x, lst_palabras_seguridad))
df_test['seguridad_descripcion'] = df_test['descripcion'].apply(lambda x: contar_cantidad_palabras(x, lst_palabras_seguridad))

df_train['moderno_descripcion'] = df_train['descripcion'].apply(lambda x: contar_cantidad_palabras(x, lst_palabras_moderno))
df_test['moderno_descripcion'] = df_test['descripcion'].apply(lambda x: contar_cantidad_palabras(x, lst_palabras_moderno))

df_train['hermoso_descripcion'] = df_train['descripcion'].apply(lambda x: contar_cantidad_palabras(x, lst_palabras_hermoso))
df_test['hermoso_descripcion'] = df_test['descripcion'].apply(lambda x: contar_cantidad_palabras(x, lst_palabras_hermoso))

df_train['estado_descripcion'] = df_train['descripcion'].apply(lambda x: contar_cantidad_palabras(x, lst_palabras_estado))
df_test['estado_descripcion'] = df_test['descripcion'].apply(lambda x: contar_cantidad_palabras(x, lst_palabras_estado))
# PALABRAS EN TITULO
df_train['seguridad_titulo'] = df_train['titulo'].apply(lambda x: contar_cantidad_palabras(x, lst_palabras_seguridad))
df_test['seguridad_titulo'] = df_test['titulo'].apply(lambda x: contar_cantidad_palabras(x, lst_palabras_seguridad))

df_train['moderno_titulo'] = df_train['titulo'].apply(lambda x: contar_cantidad_palabras(x, lst_palabras_moderno))
df_test['moderno_titulo'] = df_test['titulo'].apply(lambda x: contar_cantidad_palabras(x, lst_palabras_moderno))

df_train['hermoso_titulo'] = df_train['titulo'].apply(lambda x: contar_cantidad_palabras(x, lst_palabras_hermoso))
df_test['hermoso_titulo'] = df_test['titulo'].apply(lambda x: contar_cantidad_palabras(x, lst_palabras_hermoso))

df_train['estado_titulo'] = df_train['titulo'].apply(lambda x: contar_cantidad_palabras(x, lst_palabras_estado))
df_test['estado_titulo'] = df_test['titulo'].apply(lambda x: contar_cantidad_palabras(x, lst_palabras_estado))
def log_palabras (cantidad_palabras, cadena_completa):
    long_cadena = len(cadena_completa.split())
    if (long_cadena == 0):
        return 0
    return np.log((cantidad_palabras / long_cadena) + 1)
df_train['cantidad_palabras_descripcion'] = df_train['seguridad_descripcion'] + df_train['moderno_descripcion'] + \
                                            df_train['hermoso_descripcion'] + df_train['estado_descripcion']

df_test['cantidad_palabras_descripcion'] = df_test['seguridad_descripcion'] + df_test['moderno_descripcion'] + \
                                            df_test['hermoso_descripcion'] + df_test['estado_descripcion']

df_train['relacion_palabras_descripcion'] = df_train.cantidad_palabras_descripcion.combine(df_train.descripcion, func=log_palabras)
df_test['relacion_palabras_descripcion'] = df_test.cantidad_palabras_descripcion.combine(df_test.descripcion, func=log_palabras)<jupyter_output><empty_output><jupyter_text>Es Avenida<jupyter_code>lst_palabras_avenida = ['avenida', 'av', 'av.']

def direccion_es_avenida(direccion):
    for sinonimo_avenida in lst_palabras_avenida:
        if sinonimo_avenida in direccion.split():
            return 1
    return 0
df_train['es_avenida'] = df_train['direccion'].apply(direccion_es_avenida)
df_test['es_avenida'] = df_test['direccion'].apply(direccion_es_avenida)<jupyter_output><empty_output><jupyter_text>Es Ciudad Capital<jupyter_code>dic_estado_capital = {
    'Aguascalientes': 'Aguascalientes',
    'Baja California Norte': 'Mexicali',
    'Baja California Sur': 'La Paz',
    'Campeche': 'Campeche',
    'Chiapas': 'Tuxtla Gutiérrez',
    'Chihuahua': 'Chihuahua',
    'Coahuila': 'Saltillo',
    'Colima': 'Colima',
    'Distrito Federal': 'Ciudad de México',
    'Durango': 'Durango',
    'Edo. de México': 'Toluca',
    'Guanajuato': 'Guanajuato',
    'Guerrero': 'Chilpancingo de los Bravo',
    'Hidalgo': 'Pachuca',
    'Jalisco': 'Guadalajara',
    'Michoacán': 'Morelia',
    'Morelos': 'Cuernavaca', 
    'Nayarit': 'Tepic',
    'Nuevo León': 'Monterrey',
    'Oaxaca': 'Oaxaca de Juárez',
    'Puebla': 'Puebla',
    'Querétaro': 'Querétaro',
    'Quintana Roo': 'Chetumal',
    'San luis Potosí': 'San Luis Potosí',
    'Sinaloa': 'Culiacán',
    'Sonora': 'Hermosillo',
    'Tabasco': 'Villahermosa',
    'Tamaulipas': 'Ciudad Victoria',
    'Tlaxcala': 'Tlaxcala',
    'Veracruz': 'Xalapa',
    'Yucatán': 'Mérida',
    'Zacatecas': 'Zacatecas',
    'Sin datos': ''
}
def ciudad_es_capital_de_provincia(ciudad, provincia):
    if (ciudad == dic_estado_capital[provincia]):
        return 1
    return 0
df_train['es_ciudad_capital'] = df_train.ciudad.combine(df_train.provincia, func=ciudad_es_capital_de_provincia)
df_test['es_ciudad_capital'] = df_test.ciudad.combine(df_test.provincia, func=ciudad_es_capital_de_provincia)<jupyter_output><empty_output><jupyter_text>TOP15 de Ciudades más turísticas<jupyter_code>lst_top15_ciudades_turisticas = [
    'Ciudad de México', 'Rivera Maya', 'Cancún', 'Los Cabos', 'Guadalajara', 'Puerto Vallarta', 'Monterrey', 'Acapulco', 'Nuevo Vallarta',
    'Mazatlán', 'Puebla', 'Querétaro', 'Mérida', 'Veracruz', 'Ixtapa Zihuatanejo'
]
df_train['ciudad_turistica_top15'] = df_train['ciudad'].apply(lambda x: 1 if (x in lst_top15_ciudades_turisticas) else 0)
df_test['ciudad_turistica_top15'] = df_test['ciudad'].apply(lambda x: 1 if (x in lst_top15_ciudades_turisticas) else 0)<jupyter_output><empty_output><jupyter_text>Mes y Año de publicación<jupyter_code>df_train['fecha'] = pd.to_datetime(df_train['fecha'])
df_test['fecha'] = pd.to_datetime(df_test['fecha'])

df_train['anio'] = df_train['fecha'].dt.year
df_test['anio'] = df_test['fecha'].dt.year

df_train['mes'] = df_train['fecha'].dt.month
df_test['mes'] = df_test['fecha'].dt.month
df_train.columns<jupyter_output><empty_output><jupyter_text>Eliminamos features repetidos y complejos<jupyter_code>drop = ['titulo', 'descripcion', 'direccion', 'fecha']

df_train = df_train.drop(drop, axis=1)
df_test = df_test.drop(drop, axis=1)
df_train.head()<jupyter_output><empty_output><jupyter_text>Aplicamos encodings a los features categoricos<jupyter_code>import category_encoders as ce

cat_features = ['tipodepropiedad', 'ciudad', 'provincia']

cb_features = ['ciudad']
oh_features = ['tipodepropiedad', 'provincia']

#Elegimos un metodo de encode para estos features, y comentamos el resto de los metodos
#O elegimos distintos metodos dependiendo del feature<jupyter_output><empty_output><jupyter_text>CatBoostEncoding<jupyter_code>catb_enc = ce.CatBoostEncoder(cols=cat_features)
catb_enc.fit(df_train[cat_features], df_train['precio'])

df_train = df_train.join(catb_enc.transform(df_train[cat_features]).add_suffix('_cb'))
df_test = df_test.join(catb_enc.transform(df_test[cat_features]).add_suffix('_cb'))<jupyter_output><empty_output><jupyter_text>One Hot Encoding<jupyter_code>'''one_hot_enc = ce.OneHotEncoder()
one_hot_encoded = one_hot_enc.fit_transform(df_train[oh_features])

df_train = df_train.join(one_hot_encoded.add_suffix("_oh"))
df_test = df_test.join(one_hot_encoded.add_suffix("_oh"))'''
df_train.shape
df_test.shape
#Dropeamos los features con strings ya encodeados
#Dejamos los dataset listos para modelar

df_train = df_train.drop(cat_features, axis=1)
df_test = df_test.drop(cat_features, axis=1)<jupyter_output><empty_output><jupyter_text>Feature Selection<jupyter_code>from catboost import CatBoostRegressor

feature_cols = df_train.columns.tolist()
feature_cols.remove('precio')

X = df_train[feature_cols]
y = df_train['precio']

CatBoost = CatBoostRegressor(loss_function='MAE')
CatBoost_fit = CatBoost.fit(X, y)
features = pd.DataFrame(index=feature_cols)
features['imp'] = CatBoost_fit.feature_importances_
features = features.sort_values(['imp'], ascending = False)

plt.style.use('default')
plt.rcParams['figure.figsize'] = (10, 10)
sns.set(style="whitegrid")

g = sns.barplot(y=features.index, x=features.imp, \
                palette=sns.color_palette("Reds_d", 10));

g.set_title('Importancia de Features de CATBoost', fontsize=15);
g.set_xlabel('Valor');
g.set_ylabel('Nombre del Feature');
k=40

features_to_drop = features.nsmallest((df_train.columns.size - k), 'imp').index.tolist()
if 'id' in features_to_drop: features_to_drop.remove('id')
features_to_drop
#Dropeamos los features menos importantes
df_train = df_train.drop(features_to_drop, axis=1)
df_test = df_test.drop(features_to_drop, axis=1)<jupyter_output><empty_output><jupyter_text>Guardo Features generados<jupyter_code>df_train.to_csv('../data/train_con_features_encoded.csv')
df_test.to_csv('../data/test_con_features_encoded.csv')<jupyter_output><empty_output>
{'fraction_non_alphanumeric': 0.14286378861183477, 'fraction_numerical': 0.0035820617789356158, 'mean_word_length': 6.976623376623377, 'pattern_counts': {'":': 0, '<': 109, '<?xml version=': 0, '>': 111, 'https://': 0, 'lorem ipsum': 0, 'www.': 0, 'xml': 0}, 'pii_count': 0, 'substrings_counts': 0, 'word_list_counts': {'cursed_substrings.json': 10, 'profanity_word_list.json': 0, 'sexual_word_list.json': 0, 'zh_pornsignals.json': 0}}
{'chain_length': '27', 'dir': 'jupyter-structured-clean-dedup', 'id': '28934', 'license': 'Apache-2.0', 'n_tokens_mistral': 8504, 'n_tokens_neox': 8305, 'n_words': 1116, 'path': 'creacionFeatures_v2.ipynb', 'repo_name': 'cessar5/7506_20192C', 'size': '21496'}