<jupyter_start><jupyter_text><jupyter_code>! git clone https://github.com/nestorap/food-not-food.git
import pandas as pd
import numpy as np
import os
import matplotlib.pyplot as plt
import csv
import ast
from nltk.corpus import wordnet as wn
import nltk
import random
# Descargamos palabrasgo obtener las que son de comida

nltk.download('popular')
# Aquí leemos los nombres de las clases de las imágenes

with open("food-not-food/imges_list.txt", "r") as f:
  images_classes = ast.literal_eval(f.read())
# Recorremos los items del diccionario

for k, v in images_classes.items():
  if "banana" in v:
    print(k)<jupyter_output>954<jupyter_text>Nombre de comidas de nltk<jupyter_code># Obtenemos las palabras de comida del dataset de nltk
# Con esta lista podemos filtrar las imágenes para sacar aquellas fotos que sean de comida y que no
food = wn.synset("food.n.02")
food_list = list(set([w for s in food.closure(lambda s: s.hyponyms()) for w in s.lemma_names()])) #hyponyms parece ser que significa sinónimos

# Check para banana
"banana" in food_list<jupyter_output><empty_output><jupyter_text>Filtramos los items para que coincidan a la hora de descargar<jupyter_code># limpiamos los string para eliminar algunos signos de puntuación

lista_food = [food_item.lower().split("_") for food_item in food_list]
# Unimos las palabras en una misma lista. La celda de antes obtenemos una lista de listas de palabras

food_lista = [food for food_sublist in lista_food for food in food_sublist]
 # checkeamos

 for k,v in images_classes.items():
   if v.lower() in food_lista:
     print(k, v)
imagenet_food_clases = dict()

for k,v in images_classes.items():
  imagenet_class_set = set([space_word.strip(" ") for space_word in v.lower().split(",")]) 
  if imagenet_class_set.intersection(food_lista):
    imagenet_food_clases[k] = v
# Una vez que tenemos las clases vamos a ver cuales no deberian estar aqui. Vamos a filtrar manualmente y poner los indices que no deberian ser comida

no_food = [457, 494, 567, 626, 723, 738, 760, 923, 972, 976]
# Del diccionario que hemos obtenido, eliminamos aquellas llaves que no sean comida

imagenet_manual_filter_clases = dict()

for k,v in imagenet_food_clases.items():
  if k not in no_food: # no queremos las llaves que no sean comida
    imagenet_manual_filter_clases[k] = v
# Vamos a sacar una lista de las llaves del diccionario de comida para mas tarde filtrar y sacar las clases que no son comida

llaves_comida = [i for i in imagenet_manual_filter_clases.keys()]<jupyter_output><empty_output><jupyter_text>Sacaremos lista de comida y no-comida de imagenet<jupyter_code>imagenet_non_food_clases = dict()

for k,v in images_classes.items():
  if k not in llaves_comida:
    imagenet_non_food_clases[k] = v<jupyter_output><empty_output><jupyter_text>Siguientes fase del proyecto1- Hemos filtrado las comidas y las no-comidas del dataset con los nombres y sus índices. \2- Ahora parece ser que tenemos que seguir otra regla para que Imagenet entienda las clases que queremos. \3- Hay que leer un csv de github que aparece en el tutorial \4- Volver 10 min atras en el video para recordar lo que estaba haciendo----  Imagenet keysEl script para descargar las imágenes utiliza las llaves de las clases de Imagenet. Por ejemplo --> n09858165 n01539573 n03405111.  Vamos a mapear la lista para sacar esas llaves o ids.Imagenet data downloader script - https://github.com/mf1024/ImageNet-Datasets-Downloader<jupyter_code># Aquí tenemos las imagenes de Imaganet con sus clases y llaves

df = pd.read_csv("https://raw.githubusercontent.com/mf1024/ImageNet-Datasets-Downloader/master/classes_in_imagenet.csv")
df["class_name"] = df.loc[:,"class_name"].str.lower()
 # Borramos los nans para que no nos fastidien al filtrar

df.dropna(inplace=True)
# Filtramos el dataframe con las clases que tenemos en la lista de food_list

df_no_food = df.loc[~df["class_name"].isin(food_lista),:]
df_food = df.loc[df["class_name"].isin(food_lista),:]
# Eliminamos las clases que no son comida del df_food
# Lo haremos de manera manual. Mejor hacerlo de manera automática siempre que se pueda

no_food_list = [
                "ball",
                "puppy",
                "dog",
                "game",
                "bar",
                "blade",
                "garden",
                "hand",
                "head",
                "jacket",
                "junk",
                "key",
                "leg",
                "oven",
                "pin",
                "pinwheel",
                "plate",
                "pot",
                "rack",
                "refrigerator",
                "saddle",
                "shank",
                "spring",
                "steamer",
                "stick",
                "temple",
                "turck",
                "turban",
                "ring",
                "cup",
                "rock",
                "shell",
                "pilot",
                "runner",
                "smith",
                "ash",
                "sand"
]


# En la lista anterior tenemos nombres que no son comida en la lista que sí lo son. Esos nombres los vamos a filtrar para quitarlo del df de comida

df_food = df_food.loc[(~df["class_name"].isin(no_food_list)),:]
df_food.shape[0]
# Hacemos lista de food clases

# Lista de los ids de las clases
imagenet_food_class_ids = df_food.loc[:,"synid"].tolist()
# Lista de los nombres de las clases
imagenet_food_class_names = df_food.loc[:,"class_name"].tolist()
# Unimos ids y nombres en un diccionario
imagenet_food_class_name_and_ids_dict = dict(zip(imagenet_food_class_ids, imagenet_food_class_names))
# Hacemos lista de no_food clases

# Lista de los ids de las clases
imagenet_no_food_class_ids = df_no_food.loc[:,"synid"].tolist()
# Lista de los nombres de las clases
imagenet_no_food_class_names = df_no_food.loc[:,"class_name"].tolist()
# Unimos ids y nombres en un diccionario
imagenet_no_food_class_name_and_ids_dict = dict(zip(imagenet_no_food_class_ids, imagenet_no_food_class_names))

# Lista de los ids de las clases de food
food_class_id_list = list(imagenet_food_class_name_and_ids_dict.keys())

# Lista de los ids de las clases de no_food
no_food_class_id_list = list(imagenet_no_food_class_name_and_ids_dict.keys())

# Hacemos funcion para convertir la lista en string para pasarlo al script

def convert_list(list):
  empty_string = ""
  for item in list:
    empty_string += " "+item
  empty_string = empty_string[1:]
  return empty_string

# Obtenemos los ids para pasarle al script del downloader
food_class_id_string = convert_list(food_class_id_list)
no_food_class_id_string = convert_list(no_food_class_id_list)<jupyter_output><empty_output><jupyter_text>Descargamos los datos con comandos en bashEn esta parte vamos a descargar las imágenes del repo de githubCopiamos dos carpetas con imagenes en el directorio "model_test_images" para hacer una red neuronal pequeña. \Copiamos 2 directorios del dataset descargado de manera random con el siguiente comando en la consola --> cp -r imagenet_images/imagenet_images/'African violet' model_test_images<jupyter_code>! git clone https://github.com/mf1024/ImageNet-Datasets-Downloader.git
from IPython.display import JSON
from google.colab import output
from subprocess import getoutput
import os

def shell(command):
  if command.startswith('cd'):
    path = command.strip().split(maxsplit=1)[1]
    os.chdir(path)
    return JSON([''])
  return JSON([getoutput(command)])
output.register_callback('shell', shell)
#@title Colab Shell
%%html
<div id=term_demo></div>
<script src="https://code.jquery.com/jquery-latest.js"></script>
<script src="https://cdn.jsdelivr.net/npm/jquery.terminal/js/jquery.terminal.min.js"></script>
<link href="https://cdn.jsdelivr.net/npm/jquery.terminal/css/jquery.terminal.min.css" rel="stylesheet"/>
<script>
  $('#term_demo').terminal(async function(command) {
      if (command !== '') {
          try {
              let res = await google.colab.kernel.invokeFunction('shell', [command])
              let out = res.data['application/json'][0]
              this.echo(new String(out))
          } catch(e) {
              this.error(new String(e));
          }
      } else {
          this.echo('');
      }
  }, {
      greetings: 'Welcome to Colab Shell',
      name: 'colab_demo',
      height: 250,
      prompt: 'colab > '
  });<jupyter_output><empty_output><jupyter_text>Descarga de los datos en el jupyterAquí, con código en una celda de jupyter, también podemos descargar las imágenes sin ncesidad de abrir una consola<jupyter_code>/content/food-not-food/data/imagenet_images/imagenet_images/Beaujolais

# Creamos los directorios de las imágenes
!mkdir data/
# Creamos los directorios para los datos de comida y de no comida
!mkdir data/food_images
!mkdir data/no_food_images

# Creamos un directorio para imágenes random
!mkdir food-not-food/data/imagenet_images

# Descargamos las imágenes de comida
!python ImageNet-Datasets-Downloader/downloader.py \-data_root food-not-food/data/food_images \-use_class_list=True \-class_list $food_class_id_string \-images_per_class 100

# DEscargamos las imágenes de no_food
!python ImageNet-Datasets-Downloader/downloader.py \-data_root food-not-food/data/imagenet_images \-number_of_classes 1000 \-images_per_class 50<jupyter_output><empty_output><jupyter_text>Construcción del modelo<jupyter_code>!pip install tflite_model_maker
import tensorflow as tf
import tflite_model_maker<jupyter_output><empty_output><jupyter_text>Creamos el train y test de los datos<jupyter_code># Creamos el directorio de train
!mkdir model_test_images/train

# Creamos el directorio de test
!mkdir model_test_images/test
# Listamos las imágenes de los distintas muestras
beau_list = os.listdir("model_test_images/Beaujolais")
violet_list = os.listdir("model_test_images/African violet")
# Hacemos split

def train_test_list(target_dir):
  image_list = os.listdir(target_dir)

  random.seed(42)
  train_split = int(0.8 * len(image_list))
  # Sacamos una muestra random
  train_image_list = random.sample(image_list, train_split)
  test_image_list = list(set(image_list).difference(set(train_image_list)))

  return train_image_list, test_image_list

# Sacamos el train y el test
train_image_list, test_image_list = train_test_list("model_test_images/Beaujolais")<jupyter_output>45 12<jupyter_text>Estado y siguientes pasos1- Estado:- Se ha sacado una lista con el nombre de las imágenes de manera aletatoria para test y train.- Se han descargado las imágenes con un comando de bash y se han creado diferentes directorios. Todo parten de /data, y ahí tenemos food_images, no_food_images, imagenet_images(muestra random de todas las clases) y model_test_images(de donde vamos a sacar para el primer modelo pequeño). Cuidado en este paso por si tengo que descargarlas de nuevo.2- Siguientes pasos:- Minutos del vídeo 4:09.- Se están sacando aún las muestras para entrenar el primer modelo. Se quiere hacer listando las imágenes y seleccionando de manera aleatoria en test y train.- Etiquetar las imágenes. Como están en directorios separados, supongo que eso se hará de manera automática con alguna función en python.- Entrenar la primera red neuronal<jupyter_code><jupyter_output><empty_output>
{'fraction_non_alphanumeric': 0.08705297719407223, 'fraction_numerical': 0.009583814003017126, 'mean_word_length': 3.872460008646779, 'pattern_counts': {'":': 0, '<': 47, '<?xml version=': 0, '>': 50, 'https://': 7, 'lorem ipsum': 0, 'www.': 0, 'xml': 0}, 'pii_count': 0, 'substrings_counts': 0, 'word_list_counts': {'cursed_substrings.json': 11, 'profanity_word_list.json': 0, 'sexual_word_list.json': 0, 'zh_pornsignals.json': 0}}
{'chain_length': '10', 'dir': 'jupyter-structured-clean-dedup', 'id': '429613', 'license': 'MIT', 'n_tokens_mistral': 3948, 'n_tokens_neox': 3808, 'n_words': 1109, 'path': 'Preprocesamiento.ipynb', 'repo_name': 'nestorap/food-not-food', 'size': '11269'}