# Phind AI Releases Their 70B Model

Phind AI has released their Phind-70B model, which is their largest and most performant model to date. This model is based on the CodeLlama-70B model and is fine-tuned on an additional 50 billion tokens, resulting in significant improvements. Phind-70B supports a context window of 32K tokens and scores 82.3% on HumanEval, surpassing the latest GPT-4 Turbo score of 81.1% in their evaluation. It also runs at up to 80 tokens per second, providing high-quality answers for technical topics efficiently.

Phind-70B is faster than GPT-4 Turbo, running at 80+ tokens per second compared to GPT-4 Turbo’s ~20 tokens per second. This speed is achieved by running NVIDIA’s TensorRT-LLM library on H100 GPUs, with ongoing optimizations to further enhance inference speed. Phind-70B is available for free to try without a login, with the option to access higher limits by subscribing to Phind Pro.

## Phind-70B Examples

### Solving Hard Leetcode Problems

``````You are given an m x n integer array grid where grid[i][j] could be:

1 representing the starting square. There is exactly one starting square.
2 representing the ending square. There is exactly one ending square.
0 representing empty squares we can walk over.
-1 representing obstacles that we cannot walk over.

Return the number of 4-directional walks from the starting square to the ending square, that walk over every non-obstacle square exactly once.``````

This is from Leetcode 980. Unique Paths III.

```from typing import List

class Solution:
def uniquePathsIII(self, grid: List[List[int]]) -> int:
self.directions = [(0,  1), (0, -1), (1,  0), (-1,  0)]  # Right, Left, Down, Up
self.empty_squares =  1  # Start counting from  1 to include the start square
self.paths =  0
self.start = None

# Find the starting point and count empty squares
for i in range(len(grid)):
for j in range(len(grid[0])):
if grid[i][j] ==  1:
self.start = (i, j)
elif grid[i][j] ==  0:
self.empty_squares +=  1

def dfs(x, y, empty_squares):
if not (0 <= x < len(grid)) or not (0 <= y < len(grid[0])) or grid[x][y] <  0:
return  0
if grid[x][y] ==  2:
return  1 if empty_squares ==  0 else  0
grid[x][y] = -2  # Temporarily mark as visited
self.paths += sum(dfs(x + dx, y + dy, empty_squares -  1) for dx, dy in self.directions)
grid[x][y] =  0  # Unmark after exploring all paths
return  0

dfs(*self.start, self.empty_squares)
return self.paths
```

Unfortunately it was not able to get the initial test to pass.

### Frontend UI Code

Prompt:

``Generate a header using tailwind css. We want a logo on the left, a home, about and contact link in the center. On the right we want a Log In and Sign Up buttons``
```<header class="bg-gray-800 text-white p-4 flex items-center justify-between">
<!-- Logo -->
<div class="flex items-center">
<img src="path/to/your/logo.png" alt="Logo" class="h-8 w-auto">
</div>

<nav class="hidden md:flex space-x-4">
<a href="#" class="hover:text-gray-300">Home</a>
<a href="#" class="hover:text-gray-300">Contact</a>
</nav>

<div class="flex space-x-4">
<button class="bg-blue-500 hover:bg-blue-700 text-white font-bold py-2 px-4 rounded">
</button>
<button class="bg-green-500 hover:bg-green-700 text-white font-bold py-2 px-4 rounded">
</button>
</div>

```

Ok this one was actually pretty impressive and had great coherence.

### Working With Libraries

Prompt:

``Given a NumPy array arr with shape (3, 4, 5), reshape it into a new array with shape (6, 10).``
```import numpy as np

# Assuming arr is your original array with shape (3,  4,  5)
# arr = np.random.rand(3,  4,  5)  # Example of how to create such an array

# Reshape the array
new_arr = arr.reshape(6,  10)

print(new_arr.shape)  # This should output: (6,  10)
```

Explanation:

1. `arr.reshape(2, 3, 4, 5)`: This reshapes the array `arr` into a four-dimensional array with shape (2, 3, 4, 5). This is an intermediate step to achieve the desired shape of (6, 10).
2. `arr.transpose(0, 2, 1, 3)`: This transposes the axes of the array `arr` in the following order: (0, 2, 1, 3). This effectively swaps the first and second dimensions, and the third and fourth dimensions. This results in an array with shape (2, 4, 3, 5).
3. `arr.reshape(6, 10)`: Finally, this reshapes the array `arr` into a two-dimensional array with shape (6, 10). This achieves the desired output shape.

This solution demonstrates an understanding of NumPy’s `reshape` and `transpose` functions, as well as the concept of reshaping multidimensional arrays.

## Closing Thoughts

We’ve all seen the benchmarks on how Phind AI can beat GPT-4. Benchmarks tend to not be so accurate, many models seems to be contaminated just to approach proprietary models in coding benchmarks. Overall it’s a decent model, I wouldn’t say it’s better than GPT-4, but certainly better at than most, for programming at least. Also they don’t mention what it actually beats GPT on. Every time I see one of these it “wins” on incredibly simple and small functions, while not even being able to understand more complex requests.

### How to 10x Your LLM Prompting With DSPy

Tired of spending countless hours tweaking prompts for large...

### Google Announces A Cost Effective Gemini Flash

At Google's I/O event, the company unveiled Gemini Flash,...

### WordPress vs Strapi: Choosing the Right CMS for Your Needs

With the growing popularity of headless CMS solutions, developers...

### JPA vs. JDBC: Comparing the two DB APIs

Introduction The eternal battle rages on between two warring database...

### Meta Introduces V-JEPA

The V-JEPA model, proposed by Yann LeCun, is a...

Subscribe to our AI newsletter. Get the latest on news, models, open source and trends.
Don't worry, we won't spam. 😎

You have successfully subscribed to the newsletter

There was an error while trying to send your request. Please try again.

Lusera will use the information you provide on this form to be in touch with you and to provide updates and marketing.