Qué significa el error?

Ya que el error salta en la línea que dice:

for x_i, y_i in in_random_order(data):

el problema es que in_random_order(data) ha generado como resultado None (o un iterable cuyo primer elemento es None en cuyo caso fallaría el desempaquetado con el mismo mensaje de error).

¿Por qué sucede?

¿Por qué estará devolviendo None esa la función? Veamos su código:

def in_random_order(data):
  """generator that returns the elements if data in random order"""
  indexes = [i for i, _ in enumerate(data)] # create a list of indexes
  random.shuffle(indexes) # suffle them
  for i in indexes:
    return data[i]

Vemos que debería estar devolviendo data[i], pero el data que le estás pasando se inicializa en esta otra línea, de otra función:

data = zip(x,y)

O sea que data no es una lista, sino el resultado de un zip(). Ocurre que este resultado, aunque es un iterable, no es indexable. No puedes usarlo como si fuera una lista para tratar de obtener su resultado i-ésimo, como puedes comprobar con este experimento:

>>> test = zip(x, y)
>>> test[1]
TypeError: 'zip' object is not subscriptable

Entonces la función debería haber generado esa excepción al llegar al return data[i]. Sin embargo no ha generado tal excepción sino que ha retornado None¿cómo pudo suceder esto?

Sólo hay una forma. No llegó nunca a ejecutar esa línea. Y ésto solo puede suceder si este bucle:

  for i in indexes:
    return data[i]

no itera ni una sola vez. Es decir, si el iterable indexes está vacío. Esto es de hecho lo que ocurre como puedes comprobar si añades un print(indexes) delante del bucle.

Esto significa por tanto que el valor de data que le llega es un objeto zip() agotado.

¿Qué es un iterable agotado?

Es un iterable por el que ya has iterado una vez. Los iterables en python, una vez llegas a su final, no puedes volver a iterar por ellos. Rápida demostración:

>>> a = zip(x, y)
>>> test = [ v for v in a ]
# La línea anterior no da problemas. `a` es un iterable, y podemos iterar por él
# Si imprimiéramos ahora el valor de `test` veríamos todos sus elementos
# No lo hago porque es largo

>>> len(test)
22

>>> test2 = [ v for v in a ]
# Esta línea tampoco daría problemas, pero ya que el objeto zip se ha agotado
# no se realizará niguna iteración. test2 resulta vacío

>>> len(test2)
0

Por tanto tu código itera sobre data en algún momento antes de pasarlo como parámetro a in_random_order().

Efectivamente vemos que lo hace en la línea:

    value = sum(target_fn(x_i, y_i, theta) for x_i, y_i in data)

Es aquí donde data queda agotado, y por tanto al pasarlo después como parámetro a in_random_order() ya no se obtienen más elementos al iterar sobre data.

¿Y si quiero iterar más veces? ¿no se puede?

Esto nos lleva a tu pregunta. Seguramente tú te sospechabas que estaba pasando algo de esto pues preguntabas "usar un objeto zip de forma permanente", que entiendo que viene a significar que quieres iterar sobre él varias veces.

Ya hemos visto que sobre un iterador sólo se puede iterar una vez. Pero si a partir del iterador construyes una lista, matas dos pájaros de un tiro ya que si data fuese una lista:

• Podrías iterar múltiples veces por ella (porque cada vez que lo intentas Python construye para ella un nuevo iterador)
• Podrías acceder a data[i], resolviendo otro problema que tenías antes.

Así pues, basta cambiar esta asignación:

data = zip(x, y)

por esta otra:

data = list(zip(x, y))

El constructor list() itera por los contenidos del objeto zip(), creando con ellos una lista.

Pero hay más errores

Con ese cambio ahora rompe por otra razón:

---> 57     for x_i, y_i in in_random_order(data):
     58       gradient_i = gradient_fn(x_i, y_i, theta)
     59       theta = vector_substract(theta, scalar_multiply(alpha_gradient_i))

ValueError: too many values to unpack (expected 2)

Ahora resulta que return data[i] tiene más valores de los que se esperaban (se esperaban 2, uno para x_i y otro para y_i. En vez de eso se obtienen tres. ¿Por qué?

En este caso el error es más sutil. Y es que tu función in_random_order() no hace en realidad lo que tú querías. Pretendías que devolviera los elementos de data en orden aleatorio, pero en realidad sólo te devuelve el primer elemento de data, debido a que en este bucle:

  for i in indexes:
    return data[i]

retornas inmediatamente en la primera iteración. Así que la función en realidad devuelve data[indexes[0]] y termina. Lo que devuelve será una tupla de este estilo: ((1, 2, 3), 4) con un elemento de x y otro de y.

El bucle for x_i, y_i in .... iterará sobre esa tupla, que tiene dos elementos, por tanto hará dos iteraciones. En la primera de ellas encontrará el valor (1,2,3) que intentará asignar a x_i, y_i y por eso rompe.

El problema aquí es que tu función in_random_order() debería ser un generador, pero al no contener instrucciones yield es una función normal.

Es decir, debes cambiar el return por un yield:

def in_random_order(data):
  """generator that returns the elements if data in random order"""
  indexes = [i for i, _ in enumerate(data)] # create a list of indexes
  random.shuffle(indexes) # suffle them
  for i in indexes:
    yield data[i]

Otra versión más simple sería que en lugar de ir devolviendo con yield los elementos cambiados de orden, directamente devuelva una lista completa con los elementos desordenados. Es decir, puedes sacar una copia de data, desordenarla, y devolverla:

def in_random_order(data):
  aux = data[:]
  random.shuffle(aux)
  return aux

Cualquiera de estas soluciones arregla todos los problemas que se pueden arreglar de momento, pues aparece uno nuevo `NameError: name 'vector_substract' is not defined, pero ese ya no lo puedo solucionar con el código que proporcionas.