Esempio n. 1
0
  def Convert(self, image):
    """
    Arguments:
    ---------
    image: an Image instance

    Returns:
    -------
    an instance of Input

    Description:
    -----------
    The *image* arguments has 2 attributes: *label* which indicates
    the digit represented by the image, and *pixels* a matrix 14 x 14
    represented by a list (first list is the first row, second list the
    second row, ... ), containing numbers whose values are comprised
    between 0 and 256.0. The function transforms this into a unique list
    of 14 x 14 items, with normalized values (that is, the maximum possible
    value should be 1).

    """
    # flatten matrix into list
    new_input = Input()
    new_input.values = [pixel/256.0 for row in image.pixels for pixel in row]
    return new_input
Esempio n. 2
0
  def Convert(self, image):
    """
    Arguments:
    ---------
    image: an Image instance

    Returns:
    -------
    an instance of Input

    Description:
    -----------
    The *image* arguments has 2 attributes: *label* which indicates
    the digit represented by the image, and *pixels* a matrix 14 x 14
    represented by a list (first list is the first row, second list the
    second row, ... ), containing numbers whose values are comprised
    between 0 and 256.0. The function transforms this into a unique list
    of 14 x 14 items, with normalized values (that is, the maximum possible
    value should be 1).
    
    """
    def norm_sublst(sublst):
        lst = []
        # loop over 14 because pixels is a 14x14 matrix
        for i in range(1):
            for j in range(36):
                lst.append(sublst[i][j])
        return lst
   
    i = Input()
    i.values = norm_sublst(image.pixels)
    return i
Esempio n. 3
0
  def Convert(self, image):
    """
    Arguments:
    ---------
    image: an Image instance

    Returns:
    -------
    an instance of Input

    Description:
    -----------
    The *image* arguments has 2 attributes: *label* which indicates
    the digit represented by the image, and *pixels* a matrix 14 x 14
    represented by a list (first list is the first row, second list the
    second row, ... ), containing numbers whose values are comprised
    between 0 and 256.0. The function transforms this into a unique list
    of 14 x 14 items, with normalized values (that is, the maximum possible
    value should be 1).
    
    """
    # Replace line below by content of function

    values = []
      #    comp = [pixel/256.0 for pixel in sublist in image.pixels]
    for row in image.pixels:
      values += map(lambda x:x/256.0,row)
    ret = Input()
    ret.values = values
    return ret
Esempio n. 4
0
    def Convert(self, image):
        """
    Arguments:
    ---------
    image: an Image instance

    Returns:
    -------
    an instance of Input

    Description:
    -----------
    The *image* arguments has 2 attributes: *label* which indicates
    the digit represented by the image, and *pixels* a matrix 14 x 14
    represented by a list (first list is the first row, second list the
    second row, ... ), containing numbers whose values are comprised
    between 0 and 256.0. The function transforms this into a unique list
    of 14 x 14 items, with normalized values (that is, the maximum possible
    value should be 1).
    "
    new_pixels = [None for i in range(196)]
	
    for i in range(14):
	    for j in range(14):
		    new_pixels[i*14+j] = image.pixels[i][j] / 256.0
    """

        input = Input()
        input.values = image.pixels
        return input
Esempio n. 5
0
    def Convert(self, image):
      """
      Arguments:
      ---------
      image: an Image instance

      Returns:
      -------
      an instance of Input

      Description:
      -----------
      The *image* arguments has 2 attributes: *label* which indicates
      the digit represented by the image, and *pixels* a matrix 14 x 14
      represented by a list (first list is the first row, second list the
      second row, ... ), containing numbers whose values are comprised
      between 0 and 256.0. The function transforms this into a unique list
      of 14 x 14 items, with binary values, i.e., 1 if the pixel is mostly
      dark, or 0 if it's mostly light.
      
      """
      # Replace line below by content of function
      values = []
      for i in range(len(image.pixels)):
        for j in range(len(image.pixels[i])):
          if image.pixels[i][j] >= 128:
            pixel = 1
          else:
            pixel = 0
          values.append(pixel)
      input = Input()
      input.values = values
      return input
Esempio n. 6
0
  def Convert(self, image):
    """
    Arguments:
    ---------
    image: an Image instance

    Returns:
    -------
    an instance of Input

    Description:
    -----------
    The *image* arguments has 2 attributes: *label* which indicates
    the digit represented by the image, and *pixels* a matrix 14 x 14
    represented by a list (first list is the first row, second list the
    second row, ... ), containing numbers whose values are comprised
    between 0 and 256.0. The function transforms this into a unique list
    of 14 x 14 items, with normalized values (that is, the maximum possible
    value should be 1).
    
    """
    # Replace line below by content of function
    values = []
    for i in range(len(image.pixels)):
      for j in range(len(image.pixels[i])):
        values.append(image.pixels[i][j] / 256.0)
    input = Input()
    input.values = values
    return input
Esempio n. 7
0
 def Convert(self, image):
     outer = []
     for i in image.pixels:
         for j in i:
             outer.append(j / 256.0)
     inp = Input()
     inp.values = outer
     return inp