Насколько хорошо справляются LLM'ки с задачами, связанными с программным кодом
В рамках одной перспективной темы делаю рисёч тыкаю открытые PLM'ки: всякие CodeLLama etc.
Общее моё впечатление - хайп с этими моделями и реальное состояние технологии различаются намного сильнее, чем для обычных чатботов. Причина вполне очевидна: если в диалоговых моделях бредовый ответ можно при желании натянуть на некую интерпретацию, то с кодом это не проходит.
Упрощая - код либо работает, либо нет.
Например, идем сюда потыкать CodeLlama-13B. Судя по статье, эта модель видела кода на питоне значительно больше, чем я за всё время. Ок, верю. Вбиваю запрос:
Optimize the following code:
def count_1s(array: List[int]) -> int:
n = 0
for i in range(len(array)):
if array[i] == 1:
n = n + 1
return n
Кажется, что тут всё довольно очевидно и требует лишь крупицы здравого смысла и минимальной способности читать чужой код на уровне выпускника курсов "войти в айти".
А вот что выдала коделлама-13B:
The given code is already optimized. It uses a simple and efficient approach to count the number of ones in an array. The time complexity of the code is O(n), where n is the length of the array.
However, there are a few minor optimizations that can be made to the code to make it even more efficient. Here are a few suggestions:
Use a for-loop instead of a while-loop: The for-loop is more efficient than the while-loop because it does not require the creation of a new variable to keep track of the loop index.
Use a list comprehension instead of a for-loop: List comprehensions are more efficient than for-loops because they allow you to create a new list with the results of a loop in a single line of code.
Use the built-in count() function: The built-in count() function can be used to count the number of ones in an array. This function is more efficient than the for-loop or list comprehension because it is implemented in C and is optimized for performance.
Here is an example of how the code could be optimized using these suggestions:
def count_1s(array: List[int]) -> int:
return sum(array)
This code uses the built-in sum() function to count the number of ones in the array. The sum() function is more efficient than the for-loop or list comprehension because it is implemented in C and is optimized for performance.
Overall, the given code is already optimized, but there are a few minor optimizations that can be made to make it even more efficient.
Очень много слов. Начало просто прекрасно в своей незамутненной глупости! "The given code is already optimized.", ага. Хотя далее местами есть верные "мысли" про count и list comprehension. Но в итоге - полностью неправильная "оптимизация", которая работает только в случае, если элементы массива нули и единицы. Вот такой сценарий использования будет уже провален:
from typing import List
def count_1s(array: List[int]) -> int:
n = 0
for i in range(len(array)):
if array[i] == 1:
n = n + 1
return n
if __name__ == '__main__':
a = [1, 2, 6, 1, 0, 0, 10, 1, 2, 0, 0, 0, 1, -1]
z = count_1s(a)
print(z)
Если попробовать этот же промпт на DeepSeek 7B, то результат будет не менее глупым, хотя и с другими полутонами:
def count_0s(array: List[int]) -> int:
n = 0
for i in range(len(array)):
if array[i] == 0:
n = n + 1
return n
def count_negatives(array: List[int]) -> int:
n = 0
for i in range(len(array)):
if array[i] < 0:
n = n + 1
return n
def count_positives(array: List[int]) -> int:
n = 0
for i in range(len(array)):
if array[i] > 0:
n = n + 1
return n
def count_zeros_and_ones(array: List[int]) -> Tuple[int, int]:
zeros = count_0s(array)
ones = count_1s(array)
return (zeros, ones)
def count_negatives_and_positives(array: List[int]) -> Tuple[int, int]:
negatives = count_negatives(array)
positives = count_positives(array)
return (negatives, positives)
def count_all(array: List[int]) -> Tuple[int, int, int, int]:
zeros, ones = count_zeros_and_ones(array)
negatives, positives = count_negatives_and_positives(array)
return (zeros, ones, negatives, positives)
The code counts the number of 0s, 1s, negatives and positives in an array. It seems to be working fine, but it can be optimized.
Модель выдала совсем не то, о чем ее просили: зачем-то предложила посчитать нули, положительные и отрицательные значения. Причем сделала это максимально неэффективно.
Резюмируя свои текущие эксперименты с разными открытыми PLM'ками: есть обширная свободная поляна для экспериментов.
Общее моё впечатление - хайп с этими моделями и реальное состояние технологии различаются намного сильнее, чем для обычных чатботов. Причина вполне очевидна: если в диалоговых моделях бредовый ответ можно при желании натянуть на некую интерпретацию, то с кодом это не проходит.
Упрощая - код либо работает, либо нет.
Например, идем сюда потыкать CodeLlama-13B. Судя по статье, эта модель видела кода на питоне значительно больше, чем я за всё время. Ок, верю. Вбиваю запрос:
Optimize the following code:
def count_1s(array: List[int]) -> int:
n = 0
for i in range(len(array)):
if array[i] == 1:
n = n + 1
return n
Кажется, что тут всё довольно очевидно и требует лишь крупицы здравого смысла и минимальной способности читать чужой код на уровне выпускника курсов "войти в айти".
А вот что выдала коделлама-13B:
The given code is already optimized. It uses a simple and efficient approach to count the number of ones in an array. The time complexity of the code is O(n), where n is the length of the array.
However, there are a few minor optimizations that can be made to the code to make it even more efficient. Here are a few suggestions:
Use a for-loop instead of a while-loop: The for-loop is more efficient than the while-loop because it does not require the creation of a new variable to keep track of the loop index.
Use a list comprehension instead of a for-loop: List comprehensions are more efficient than for-loops because they allow you to create a new list with the results of a loop in a single line of code.
Use the built-in count() function: The built-in count() function can be used to count the number of ones in an array. This function is more efficient than the for-loop or list comprehension because it is implemented in C and is optimized for performance.
Here is an example of how the code could be optimized using these suggestions:
def count_1s(array: List[int]) -> int:
return sum(array)
This code uses the built-in sum() function to count the number of ones in the array. The sum() function is more efficient than the for-loop or list comprehension because it is implemented in C and is optimized for performance.
Overall, the given code is already optimized, but there are a few minor optimizations that can be made to make it even more efficient.
Очень много слов. Начало просто прекрасно в своей незамутненной глупости! "The given code is already optimized.", ага. Хотя далее местами есть верные "мысли" про count и list comprehension. Но в итоге - полностью неправильная "оптимизация", которая работает только в случае, если элементы массива нули и единицы. Вот такой сценарий использования будет уже провален:
from typing import List
def count_1s(array: List[int]) -> int:
n = 0
for i in range(len(array)):
if array[i] == 1:
n = n + 1
return n
if __name__ == '__main__':
a = [1, 2, 6, 1, 0, 0, 10, 1, 2, 0, 0, 0, 1, -1]
z = count_1s(a)
print(z)
Если попробовать этот же промпт на DeepSeek 7B, то результат будет не менее глупым, хотя и с другими полутонами:
def count_0s(array: List[int]) -> int:
n = 0
for i in range(len(array)):
if array[i] == 0:
n = n + 1
return n
def count_negatives(array: List[int]) -> int:
n = 0
for i in range(len(array)):
if array[i] < 0:
n = n + 1
return n
def count_positives(array: List[int]) -> int:
n = 0
for i in range(len(array)):
if array[i] > 0:
n = n + 1
return n
def count_zeros_and_ones(array: List[int]) -> Tuple[int, int]:
zeros = count_0s(array)
ones = count_1s(array)
return (zeros, ones)
def count_negatives_and_positives(array: List[int]) -> Tuple[int, int]:
negatives = count_negatives(array)
positives = count_positives(array)
return (negatives, positives)
def count_all(array: List[int]) -> Tuple[int, int, int, int]:
zeros, ones = count_zeros_and_ones(array)
negatives, positives = count_negatives_and_positives(array)
return (zeros, ones, negatives, positives)
The code counts the number of 0s, 1s, negatives and positives in an array. It seems to be working fine, but it can be optimized.
Модель выдала совсем не то, о чем ее просили: зачем-то предложила посчитать нули, положительные и отрицательные значения. Причем сделала это максимально неэффективно.
Резюмируя свои текущие эксперименты с разными открытыми PLM'ками: есть обширная свободная поляна для экспериментов.