Let's compare how the different versions do by asking the model to fix bugs in some Python code as a validation exercise. First, we'll load the 2 bit version to use that as a baseline.
ollama run Granite_Instruct:8b_Q2
Once that's running, we can paste our prompt.
>>>Fix any errors in the following Python function and format it correctly:
import math
class Circle:
def __init__(self, radius):
self.radius = radius
def area(self):
return math.pi* self.radius** math.pi
def perimeter(self):
return math.pi* math.pi * self.radius
def print_circle_properties(circles):
for circle in circles:
print(f"Circle with radius {circle.radius}:")
print(f"Area: {circle.area()}")
print(f"Perimeter: {circle.perimeter()}\n")
circles = [Circle(3), Circle(5), Circle(7)]
print_circle_properties(circle)
With the 2 bit quantization, the model doesn't perform quite as well as we might hope. It misses that the equation for the area of a circle and the perimeters are both wrong. It also doesn't explain any of the errors.
I have fixed the errors in your Python code and formatted it as follows:
import math
class Circle:
def __init__(self, radius):
self.radius = radius
def area(self):
return math.pi* self.radius** math.pi
def perimeter(self):
return math.pi * self.radius
def print_circle_properties(circles):
for circle in circles:
print(f"Circle with radius {circle.radius}:")
print(f"Area: {circle.area()}")
print(f"Perimeter: {circle.perimeter()}\n")
circles = [Circle(3), Circle(5), Circle(7)]
print_circle_properties(circles)
Now let's load the Q4.
ollama run Granite_Instruct:8b_Q4
Copying and pasting the previous prompt, we get a much better response, although the 3rd item doesn't make sense.
There are a few errors in the provided Python code:
1. In the `area()` method of the `Circle` class, the `math.pi* self.radius** math.pi` should be `math.pi * (self.radius ** 2)`. This is because the area of a circle is given by pi times the square of its radius.
2. The `perimeter()` method in the `Circle` class should return `2 * math.pi * self.radius`, since the perimeter of a circle is given by 2 * pi * radius.
3. In the `print_circle_properties(circles)` function, the parameter `circle` should be `circle`.
4. The last line of code should be `print_circle_properties(circles)`, not `print_circle_properties(circle)`.
Here is the corrected code:
```python
import math
class Circle:
def __init__(self, radius):
self.radius = radius
def area(self):
return math.pi * (self.radius ** 2)
def perimeter(self):
return 2 * math.pi * self.radius
def print_circle_properties(circles):
for circle in circles:
print(f"Circle with radius {circle.radius}:")
print(f"Area: {circle.area()}")
print(f"Perimeter: {circle.perimeter()}\n")
circles = [Circle(3), Circle(5), Circle(7)]
print_circle_properties(circles)
```
Finally, we can load the 6 bit quantized model:
ollama run Granite_Instruct:8b_Q6
This answer is much better than either of the two previous versions. It catches all of the bugs in the code, gives us the correct formula for both area and perimeter, and correctly changes the last call to the print_circle_properties method.
The provided Python function contains two errors:
1. In the `area` method, there is an extra `math.pi` before `self.radius**`. It should be `return math.pi * self.radius ** 2`.
2. In the `perimeter` method, there are two `math.pi` multiplications. The correct formula for perimeter of a circle is `2 * math.pi * radius`. Therefore, it should be `return 2 * math.pi * self.radius`.
3. At the end of the code, the variable name is misspelled as `circle` instead of `circles`.
Here's the corrected version of the code:
```python
import math
class Circle:
def __init__(self, radius):
self.radius = radius
def area(self):
return math.pi * self.radius ** 2
def perimeter(self):
return 2 * math.pi * self.radius
def print_circle_properties(circles):
for circle in circles:
print(f"Circle with radius {circle.radius}:")
print(f"Area: {circle.area()}")
print(f"Perimeter: {circle.perimeter()}\n")
circles = [Circle(3), Circle(5), Circle(7)]
print_circle_properties(circles)
```
We can see that the 2 bit quantized model does save space but also is less adept at picking out errors in our code as well as fixing them and explaining them. The 4 bit model corrects all of the code errors but doesn't fully explain its instructions. The 6 bit model corrects all of the errors and explains those errors correctly and in greater detail.
